/*
	软件名称：ckplayer
	软件版本：X2
	软件作者：niandeng
	软件网站：http://www.ckplayer.com
	--------------------------------------------------------------------------------------------------------------------
	开发说明：
	使用的主要程序语言：javascript(js)及actionscript3.0(as3.0)(as3.0主要用于flashplayer部分的开发，不在该页面呈现)
	功能：播放视频
	特点：兼容HTML5-VIDEO(优先)以及FlashPlayer
	--------------------------------------------------------------------------------------------------------------------
	使用开源代码部分：
	1：flashls-http://flashls.org/
	=====================================================================================================================
*/

!(function () {
    var ckplayer = function (obj) {
        /*
			javascript部分开发所用的注释说明：
			1：初始化-程序调用时即运行的代码部分
			2：定义样式-定义容器（div,p,canvas等）的样式表，即css
			3：监听动作-监听元素节点（单击-click，鼠标进入-mouseover，鼠标离开-mouseout，鼠标移动-mousemove等）事件
			4：监听事件-监听视频的状态（播放，暂停，全屏，音量调节等）事件
			5：共用函数-这类函数在外部也可以使用
			6：全局变量-定义成全局使用的变量
			7：其它相关注释
			全局变量说明：
			在本软件中所使用到的全局变量（变量（类型）包括Boolean，String，Int，Object（包含元素对象和变量对象），Array，Function等）
			下面列出重要的全局变量：
				V:Object：视频对象
				VA:Array：视频列表（包括视频地址，类型，清晰度说明）
				ID:String：视频ID
				CB:Object：控制栏各元素的集合对象
				PD:Object：内部视频容器对象
			---------------------------------------------------------------------------------------------
			程序开始
			下面为需要初始化配置的全局变量
		*/
        //全局变量：播放器默认配置，在外部传递过来相应配置后，则进行相关替换
        this.varsDefault = {
            playerID: "", //播放器ID
            container: "", //视频容器的ID
            variable: "ckplayer", //播放函数(变量)名称
            volume: 0.8, //默认音量，范围0-1
            poster: "", //封面图片地址
            autoplay: false, //是否自动播放
            loop: false, //是否需要循环播放
            live: false, //是否是直播
            duration: 0, //指定总时间
            forceduration: 0, //强制使用该时间为总时间
            seek: 0, //默认需要跳转的秒数
            drag: "", //拖动时支持的前置参数
            front: "", //前一集按钮动作
            next: "", //下一集按钮动作
            loaded: "", //加载播放器后调用的函数
            flashplayer: false, //设置成true则强制使用flashplayer
            html5m3u8: false, //PC平台上是否使用h5播放器播放m3u8
            track: null, //字幕轨道
            cktrack: null, //ck字幕
            cktrackdelay: 0, //字幕显示延迟时间
            preview: null, //预览图片对象
            prompt: null, //提示点功能
            video: null, //视频地址
            config: "", //调用配置函数名称
            type: "", //视频格式
            crossorigin: "", //设置html5视频的crossOrigin属性
            crossdomain: "", //安全策略文件地址
            unescape: false, //默认flashplayer里需要解码
            mobileCkControls: false, //移动端h5显示控制栏
            mobileAutoFull: true, //移动端是否默认全屏播放
            playbackrate: 1, //默认倍速
            h5container: "", //h5环境中使用自定义容器
            debug: false, //是否开启调试模式
            overspread: true, //是否让视频铺满播放器
            language: "", //语言文件路径
            style: "", //风格文件路径
            //以下为广告相关配置
            adfront: "",
            adfronttime: "",
            adfrontlink: "",
            adpause: "",
            adpausetime: "",
            adpauselink: "",
            adinsert: "",
            adinserttime: "",
            adinsertlink: "",
            inserttime: "",
            adend: "",
            adendtime: "",
            adendlink: "",
            advertisements: "",
        };
        //全局变量:vars
        this.vars = {};
        //全局变量：配置文件函数
        this.ckConfig = {};
        this.jsonConfig = {}; //该变量为一次性赋值，不再变化
        //全局变量：语言配置
        this.ckLanguage = {};
        this.jsonLanguage = {}; //该变量为一次性赋值，不再变化
        //全局变量：语言配置
        this.ckStyle = {};
        this.jsonStyle = {}; //该变量为一次性赋值，不再变化
        //全局变量：右键菜单：[菜单标题,类型(link:链接，default:灰色，function：调用函数，javascript:调用js函数),执行内容(包含链接地址，函数名称),[line(间隔线)]]
        this.contextMenu = [
            ["ckplayer", "link", "http://www.ckplayer.com", "_blank"],
            ["version:X2", "default", "line"],
        ];
        //全局变量：错误提示列表
        this.errorList = [
            ["000", "Object does not exist"],
            ["001", "Variables type is not a object"],
            ["002", "Video object does not exist"],
            ["003", "Video object format error"],
            ["004", "Video object format error"],
            ["005", "Video object format error"],
            ["006", "[error] does not exist"],
            ["007", "Ajax error"],
            ["008", "Ajax error"],
            ["009", "Ajax object format error"],
            ["010", "Ajax.status:[error]"],
            ["011", "[error] File loading failed or error"],
            ["012", "[error]"],
        ];
        //全局变量：HTML5变速播放的值数组/如果不需要可以设置成null
        this.playbackRateArr = [
            [0.5, "0.5X"],
            [1, "1X"],
            [1.25, "1.25X"],
            [1.5, "1.5X"],
            [2, "2X"],
            [4, "4X"],
        ];
        //全局变量：保存倍速
        this.playbackRateTemp = 1;
        //全局变量：HTML5默认变速播放的值
        this.playbackRateDefault = 1;
        //全局变量：HTML5当前显示的字幕编号
        this.subtitlesTemp = -1;
        //全局变量：定义logo
        this.logo = "";
        //全局变量：是否加载了播放器
        this.loaded = false;
        //全局变量：计时器，监听视频加载出错的状态
        this.timerError = null;
        //全局变量：是否出错
        this.error = false;
        //全局变量：出错地址的数组
        this.errorUrl = [];
        //全局变量：计时器，监听全屏与非全屏状态
        this.timerFull = null;
        //全局变量：是否全屏状态
        this.full = false;
        //全局变量：计时器，监听当前的月/日 时=分=秒
        this.timerTime = null;
        //全局变量：计时器，监听视频加载
        this.timerBuffer = null;
        //全局变量：设置进度按钮及进度条是否跟着时间变化，该属性主要用来在按下进度按钮时暂停进度按钮移动和进度条的长度变化
        this.isTimeButtonMove = true;
        //全局变量：进度栏是否有效，如果是直播，则不需要监听时间让进度按钮和进度条变化
        this.isTimeButtonDown = false;
        //全局变量：计时，用来计算鼠标离开清晰度或字幕或倍速按钮后的计算时间标准
        this.timeButtonOver = null;
        //全局变量：鼠标离开清晰度或字幕或倍速是否需要隐藏
        this.buttonHide = false;
        //全局变量：用来模拟双击功能的判断
        this.isClick = false;
        //全局变量：计时器，用来模拟双击功能的计时器
        this.timerClick = null;
        //全局变量：计时器，监听鼠标在视频上移动显示控制栏
        this.timerCBar = null;
        //全局变量：播放视频时如果该变量的值大于0，则进行跳转后设置该值为0
        this.needSeek = 0;
        //全局变量：当前音量
        this.volume = 0;
        //全局变量：静音时保存临时音量
        this.volumeTemp = 0;
        //全局变量/变量类型：Number/功能：当前播放时间
        this.time = 0;
        //全局变量：定义首次调用
        this.isFirst = true;
        //全局变量：是否使用HTML5-VIDEO播放
        this.html5Video = true;
        //全局变量记录视频容器节点的x;y
        this.pdCoor = {
            x: 0,
            y: 0,
        };
        //全局变量：判断当前使用的播放器类型，html5video或flashplayer
        this.playerType = "";
        //全局变量：加载进度条的长度
        this.loadTime = 0;
        //全局变量：body对象
        this.body = document.body || document.documentElement;
        //全局变量：播放器
        this.V = null;
        //全局变量：保存外部js监听事件数组
        this.listenerJsArr = [];
        //全局变量：保存控制栏显示元素的总宽度
        this.buttonLen = 0;
        //全局变量：保存控制栏显示元素的数组
        this.buttonArr = [];
        //全局变量：保存播放器上新增元件的数组
        this.elementArr = [];
        //全局变量：保存播放器上弹幕的临时数组
        this.elementTempArr = [];
        //全局变量：字幕内容
        this.track = [];
        //全局变量：字幕索引
        this.trackIndex = 0;
        //全局变量：当前显示的字幕内容
        this.nowTrackShow = {
            sn: "",
        };
        //全局变量：保存字幕元件数组
        this.trackElement = [];
        //全局变量：将视频转换为图片
        this.timerVCanvas = null;
        //全局变量：animate，缓动对象数组
        this.animateArray = [];
        //全局变量：保存animate的元件
        this.animateElementArray = [];
        //全局变量：保存需要在暂停时停止缓动的数组
        this.animatePauseArray = [];
        //全局变量：预览图片加载状态/0=没有加载，1=正在加载，2=加载完成
        this.previewStart = 0;
        //全局变量：预览图片容器
        this.previewDiv = null;
        //全局变量：预览框
        this.previewTop = null;
        //全局变量：预览框的宽
        this.previewWidth = 120;
        //全局变量：预览图片容器缓动函数
        this.previewTween = null;
        //全局变量：是否是m3u8格式，是的话则可以加载hls.js
        this.isM3u8 = false;
        //全局变量：保存提示点数组
        this.promptArr = [];
        //全局变量：显示提示点文件的容器
        this.promptElement = null;
        //全局变量：控制栏是否显示
        this.conBarShow = true;
        //全局变量：是否监听过h5的错误
        this.errorAdd = false;
        //全局变量：是否发送了错误
        this.errorSend = false;
        //全局变量：控制栏是否隐藏
        this.controlBarIsShow = true;
        //全局变量，保存当前缩放比例
        this.videoScale = 1;
        //全局变量：设置字体
        this.fontFamily =
            '"Microsoft YaHei"; YaHei; "\5FAE8F6F96C59ED1"; SimHei; "9ED1\4F53";Arial';
        //全局变量：记录第一次拖动进度按钮时的位置
        this.timeSliderLeftTemp = 0;
        //全局变量：判断是否记录了总时间
        this.durationSendJS = false;
        //全局变量：初始化广告分析是否结束设置
        this.adAnalysisEnd = false;
        //全局变量：广告变量
        this.advertisements = {};
        //全局变量：是否是第一次播放视频
        this.isFirstTimePlay = true;
        //全局变量：当前需要播放的广告类型
        this.adType = "";
        //全局变量：播放广告计数
        this.adI = 0;
        //全局变量：要播放的临时地址
        this.videoTemp = {
            src: "",
            source: "",
            currentSrc: "",
            loop: false,
        };
        //全局变量：当前要播放的广告组总时间
        this.adTimeAllTotal = 0;
        //全局变量：肖前要播放的广告时间
        this.adTimeTotal = 0;
        //全局变量：用来做倒计时
        this.adCountDownObj = null;
        //全局变量：前置，中插，结尾广告是否已开始运行
        this.adPlayStart = false;
        //全局变量：目前是否在播放广告
        this.adPlayerPlay = false;
        //全局变量：当前广告是否暂停
        this.adIsPause = false;
        //全局变量：视频广告是否静音
        this.adVideoMute = false;
        //全局变量：是否需要记录当前播放的时间供广告播放结束后进行跳转
        this.adIsVideoTime = false;
        //全局变量：后置广告是否播放
        this.endAdPlay = false;
        //全局变量：暂停广告是否在显示
        this.adPauseShow = false;
        //全局变量：是否需要重置广告以实现重新播放时再播放一次
        this.adReset = false;
        //全局变量：记录鼠标在视频上点击时的坐标
        this.videoClickXy = {x: 0, y: 0};
        //全局变量：是否在播放广告时播放过视频广告
        this.adVideoPlay = false;

        //全局变量：临时存储已加载时间的变量
        this.loadTimeTemp = 0;
        //全局变量，临时存储hls形式下首次加载时是否需要暂停或播放的判断
        this.hlsAutoPlay = true;
        //全局变量，loading是否显示
        this.loadingShow = false;
        //全局变量，保存视频地址字符串的
        this.videoString = "";
        //全局变量，保存所有自定义元件的数组
        this.customeElement = [];
        //全局变量，保存PD的宽高
        this.cdWH = {w: 0, h: 0};
        //全局变量，保存所有的元素变量
        this.CB = {};
        //全局变量，调用当前路径
        // this.ckplayerPath = this.getPath();
        this.ckplayerPath = obj.jsonPath;
        if (obj) {
            this.embed(obj);
        }
    };
    ckplayer.prototype = {
        /*
			主要函数部分开始
			主接口函数：
			调用播放器需初始化该函数
		*/
        embed: function (c) {
            //c:Object：是调用接口传递的属性对象
            if (window.location.href.substr(0, 7) == "file://") {
                //如果是使用的file协议打网页则弹出提示
                alert("Please use the HTTP protocol to open the page");
                return;
            }
            if (this.isUndefined(c)) {
                this.eject(this.errorList[0]);
                return;
            }
            if (this.varType(c) != "object") {
                this.eject(this.errorList[1]);
            }
            this.vars = this.standardization(this.varsDefault, c);
            if (!this.vars["mobileCkControls"] && this.isMobile()) {
                this.vars["flashplayer"] = false;
                this.conBarShow = false;
            }
            var videoStringTemp = this.vars["video"];
            if (!videoStringTemp) {
                this.eject(this.errorList[2]);
                return;
            }
            if (this.varType(videoStringTemp) == "string") {
                if (
                    videoStringTemp.substr(0, 3) == "CK:" ||
                    videoStringTemp.substr(0, 3) == "CE:" ||
                    videoStringTemp.substr(8, 3) == "CK:" ||
                    videoStringTemp.substr(8, 3) == "CE:"
                ) {
                    this.vars["flashplayer"] = true;
                }
            }
            if (this.varType(videoStringTemp) == "object") {
                if (videoStringTemp.length > 1) {
                    if (
                        videoStringTemp[0][0].substr(0, 3) == "CK:" ||
                        videoStringTemp[0][0].substr(0, 3) == "CE:" ||
                        videoStringTemp[0][0].substr(8, 3) == "CK:" ||
                        videoStringTemp[0][0].substr(8, 3) == "CE:"
                    ) {
                        this.vars["flashplayer"] = true;
                    }
                }
            }
            this.videoString = videoStringTemp;
            this.checkUpConfig();
        },
        /*
			内部函数
			加载config文件
		*/
        checkUpConfig: function () {
            var thisTemp = this;
            var configPath = "";
            var jsTemp = null;
            if (this.vars["config"]) {
                if (this.vars["config"].substr(0, 8) != "website:") {
                    jsTemp = eval(this.vars["config"] + "()");
                    if (!this.isUndefined(jsTemp)) {
                        this.ckConfig = this.newObj(jsTemp);
                        this.jsonConfig = this.newObj(jsTemp);
                        this.loadConfig(null);
                    } else {
                        this.loadConfig(this.ckplayerPath + this.vars["config"]);
                    }
                } else {
                    this.loadConfig(this.ckplayerPath + this.vars["config"].substr(8));
                }
            } else {
                try {
                    var isFun = false;
                    try {
                        if (typeof ckplayerConfig === "function") {
                            isFun = true;
                        }
                    } catch (e) {
                    }
                    if (isFun) {
                        jsTemp = ckplayerConfig();
                        if (jsTemp) {
                            this.ckConfig = this.newObj(jsTemp);
                            this.jsonConfig = this.newObj(jsTemp);
                            this.loadConfig(null);
                        } else {
                            this.loadConfig(this.ckplayerPath + "ckplayer.json");
                        }
                    } else {
                        this.loadConfig(this.ckplayerPath + "ckplayer.json");
                    }
                } catch (e) {
                    thisTemp.sysError(thisTemp.errorList[12], e); //系统错误
                }
            }
        },
        loadConfig: function (file) {
            var thisTemp = this;
            if (file) {
                this.ajax({
                    url: file,
                    success: function (data) {
                        if (data) {
                            thisTemp.ckConfig = data;
                            thisTemp.jsonConfig = thisTemp.newObj(data);
                            if (!thisTemp.isUndefined(data["flashvars"])) {
                                thisTemp.vars = thisTemp.objectAssign(
                                    data["flashvars"],
                                    thisTemp.vars,
                                );
                            }
                            thisTemp.checkUpLanguage();
                        } else {
                            thisTemp.sysError(thisTemp.errorList[11], "Config"); //系统错误
                        }
                    },
                    error: function (data) {
                        thisTemp.sysError(thisTemp.errorList[12], data); //系统错误
                    },
                });
            } else {
                this.checkUpLanguage();
            }
        },
        /*
			内部函数
			加载语言文件
		*/
        checkUpLanguage: function () {
            var thisTemp = this;
            var languagePath = "";
            var jsTemp = null;
            if (this.vars["language"]) {
                languagePath = this.vars["language"];
            } else {
                if (this.ckConfig["languagePath"]) {
                    languagePath = this.ckConfig["languagePath"];
                }
            }
            if (languagePath) {
                if (languagePath.substr(0, 8) != "website:") {
                    jsTemp = eval(languagePath + "()");
                    if (jsTemp) {
                        this.ckLanguage = this.newObj(jsTemp);
                        this.jsonLanguage = this.newObj(jsTemp);
                        this.loadLanguage(null);
                    } else {
                        this.loadLanguage(this.ckplayerPath + languagePath);
                    }
                } else {
                    this.loadLanguage(this.ckplayerPath + languagePath.substr(8));
                }
            } else {
                try {
                    var isFun = false;
                    try {
                        if (typeof ckplayerLanguage === "function") {
                            isFun = true;
                        }
                    } catch (e) {
                    }
                    if (isFun) {
                        jsTemp = ckplayerLanguage();
                        if (jsTemp) {
                            this.ckLanguage = this.newObj(jsTemp);
                            this.jsonLanguage = this.newObj(jsTemp);
                            this.loadLanguage(null);
                        } else {
                            this.loadLanguage(this.ckplayerPath + "language.json");
                        }
                    } else {
                        this.loadLanguage(this.ckplayerPath + "language.json");
                    }
                } catch (e) {
                    thisTemp.sysError(thisTemp.errorList[12], e); //系统错误
                }
            }
        },
        loadLanguage: function (file) {
            var thisTemp = this;
            if (file) {
                this.ajax({
                    url: file,
                    success: function (data) {
                        if (data) {
                            thisTemp.ckLanguage = data;
                            thisTemp.jsonLanguage = thisTemp.newObj(data);
                            thisTemp.checkUpStyle();
                        } else {
                            thisTemp.sysError(thisTemp.errorList[11], "language.json"); //系统错误
                        }
                    },
                    error: function (data) {
                        thisTemp.sysError(thisTemp.errorList[12], data); //系统错误
                    },
                });
            } else {
                this.checkUpStyle();
            }
        },
        /*
			内部函数
			加载皮肤文件
		*/
        checkUpStyle: function () {
            var thisTemp = this;
            var stylePath = "";
            var jsTemp = null;
            var configJs = this.newObj(this.ckConfig);
            if (this.vars["style"]) {
                stylePath = this.vars["style"];
            } else {
                if (this.ckConfig["stylePath"]) {
                    stylePath = "" + this.ckConfig["stylePath"];
                }
            }
            if (stylePath) {
                if (stylePath.substr(0, 8) != "website:") {
                    jsTemp = eval(stylePath + "()");
                    if (!this.isUndefined(jsTemp)) {
                        this.jsonStyle = this.newObj(jsTemp);
                        this.ckStyle = this.newObj(jsTemp);
                        this.ckStyle["advertisement"] = this.objectAssign(
                            configJs["style"]["advertisement"],
                            this.ckStyle["advertisement"],
                        );
                        this.ckStyle = this.objectAssign(configJs["style"], this.ckStyle);
                        this.loadStyle(null);
                    } else {
                        this.loadStyle(this.ckplayerPath + stylePath);
                    }
                } else {
                    this.loadStyle(this.ckplayerPath + stylePath.substr(8));
                }
            } else {
                try {
                    var isFun = false;
                    try {
                        if (typeof ckplayerStyle === "function") {
                            isFun = true;
                        }
                    } catch (e) {
                        isFun = false;
                    }
                    if (isFun) {
                        jsTemp = ckplayerStyle();
                        if (!this.isUndefined(jsTemp)) {
                            this.jsonStyle = this.newObj(jsTemp);
                            this.ckStyle = this.newObj(jsTemp);
                            this.ckStyle["advertisement"] = this.objectAssign(
                                configJs["style"]["advertisement"],
                                this.ckStyle["advertisement"],
                            );
                            this.ckStyle = this.objectAssign(configJs["style"], this.ckStyle);
                            this.loadStyle(null);
                        } else {
                            this.loadStyle(this.ckplayerPath + "style.json");
                        }
                    } else {
                        this.loadStyle(this.ckplayerPath + "style.json");
                    }
                } catch (e) {
                }
            }
        },
        loadStyle: function (file) {
            var thisTemp = this;
            if (file) {
                var configJs = this.newObj(this.ckConfig);
                this.ajax({
                    url: file,
                    success: function (data) {
                        if (data) {
                            thisTemp.jsonStyle = thisTemp.newObj(data);
                            thisTemp.ckStyle = thisTemp.newObj(data);
                            thisTemp.ckStyle["advertisement"] = thisTemp.objectAssign(
                                configJs["style"]["advertisement"],
                                thisTemp.ckStyle["advertisement"],
                            );
                            thisTemp.ckStyle = thisTemp.objectAssign(
                                configJs["style"],
                                thisTemp.ckStyle,
                            );
                            thisTemp.loadConfigHandler();
                        } else {
                            thisTemp.sysError(thisTemp.errorList[11], "Style"); //系统错误
                        }
                    },
                    error: function (data) {
                        thisTemp.sysError(thisTemp.errorList[12], data); //系统错误
                    },
                });
            } else {
                this.loadConfigHandler();
            }
        },
        /*
			内部函数
			当config,language,style三个文件或函数处理完成后执行的动作
		*/
        loadConfigHandler: function () {
            if (
                (!this.supportVideo() && this.vars["flashplayer"] != "") ||
                (this.vars["flashplayer"] && this.uploadFlash()) ||
                !this.isMsie()
            ) {
                this.html5Video = false;
                this.getVideo();
            } else if (this.videoString) {
                //判断视频数据类型
                this.analysedVideoUrl(this.videoString);
            } else {
                this.eject(this.errorList[2]);
            }
        },
        /*
			内部函数
			根据外部传递过来的video开始分析视频地址
		*/
        analysedVideoUrl: function (video) {
            var i = 0,
                y = 0;
            var thisTemp = this;
            this.VA = []; //定义全局变量VA：视频列表（包括视频地址，类型，清晰度说明）
            if (this.varType(video) == "string") {
                //如果是字符形式的则判断后缀进行填充
                if (video.substr(0, 8) != "website:") {
                    this.VA = [[video, "", "", 0]];
                    var fileExt = this.getFileExt(video);
                    switch (fileExt) {
                        case ".mp4":
                            this.VA[0][1] = "video/mp4";
                            break;
                        case ".ogg":
                            this.VA[0][1] = "video/ogg";
                            break;
                        case ".webm":
                            this.VA[0][1] = "video/webm";
                            break;
                        default:
                            break;
                    }
                    this.getVideo();
                } else {
                    if (this.html5Video) {
                        var ajaxObj = {
                            url: video.substr(8),
                            success: function (data) {
                                if (data) {
                                    thisTemp.analysedUrl(data);
                                } else {
                                    thisTemp.eject(thisTemp.errorList[5]);
                                    this.VA = video;
                                    thisTemp.getVideo();
                                }
                            },
                            error: function (data) {
                                thisTemp.eject(thisTemp.errorList[12], data); //系统错误
                            },
                        };
                        this.ajax(ajaxObj);
                    } else {
                        this.VA = video;
                        this.getVideo();
                    }
                }
            } else if (this.varType(video) == "array") {
                //如果视频地址是数组
                if (this.varType(video[0]) == "array") {
                    //如果视频地址是二维数组
                    this.VA = video;
                }
                this.getVideo();
            } else if (this.varType(video) == "object") {
                /*
					如果video格式是对象形式，则分二种
					如果video对象里包含type，则直接播放
				*/
                if (!this.isUndefined(video["type"])) {
                    this.VA.push([video["file"], video["type"], "", 0]);
                    this.getVideo();
                } else {
                    this.eject(this.errorList[5]);
                }
            } else {
                this.eject(this.errorList[4]);
            }
        },
        /*
			对请求到的视频地址进行重新分析
		*/
        analysedUrl: function (data) {
            this.vars = this.standardization(this.vars, data);
            if (!this.isUndefined(data["video"])) {
                this.vars["video"] = data["video"];
            }
            this.analysedVideoUrl(this.vars["video"]);
        },
        /*
			内部函数
			检查浏览器支持的视频格式，如果是则将支持的视频格式重新分组给播放列表
		*/
        getHtml5Video: function () {
            var va = this.VA;
            var nva = [];
            var mobile = this.isMobile();
            var video = document.createElement("video");
            var codecs = function (type) {
                var cod = "";
                switch (type) {
                    case "video/mp4":
                        cod = "avc1.4D401E, mp4a.40.2";
                        break;
                    case "video/ogg":
                        cod = "theora, vorbis";
                        break;
                    case "video/webm":
                        cod = "vp8.0, vorbis";
                        break;
                    default:
                        break;
                }
                return cod;
            };
            var supportType = function (vidType, codType) {
                if (!video.canPlayType) {
                    this.html5Video = false;
                    return;
                }
                var isSupp = video.canPlayType(vidType + ';codecs="' + codType + '"');
                if (isSupp == "") {
                    return false;
                }
                return true;
            };
            if (this.vars["flashplayer"] || !this.isMsie()) {
                this.html5Video = false;
                return;
            }
            for (var i = 0; i < va.length; i++) {
                var v = va[i];
                if (v) {
                    if (
                        v[1] != "" &&
                        !mobile &&
                        supportType(v[1], codecs(v[1])) &&
                        v[0].substr(0, 4) != "rtmp"
                    ) {
                        nva.push(v);
                    }
                    if (
                        (this.getFileExt(v[0]) == ".m3u8" ||
                            this.vars["type"] == "video/m3u8" ||
                            this.vars["type"] == "m3u8" ||
                            v[1] == "video/m3u8" ||
                            v[1] == "m3u8") &&
                        this.vars["html5m3u8"] &&
                        !mobile
                    ) {
                        this.isM3u8 = true;
                        nva.push(v);
                    }
                }
            }
            if (nva.length > 0) {
                this.VA = nva;
            } else {
                if (!mobile) {
                    this.html5Video = false;
                }
            }
        },
        /*
			内部函数
			根据视频地址开始构建播放器
		*/
        getVideo: function () {
            var thisTemp = this;
            var v = this.vars;
            //如果存在广告字段则开始分析广告
            if (
                !this.adAnalysisEnd &&
                (v["adfront"] != "" ||
                    v["adpause"] != "" ||
                    v["adinsert"] != "" ||
                    v["adend"] != "" ||
                    v["advertisements"] != "")
            ) {
                this.adAnalysisEnd = true;
                this.adAnalysis();
                return;
            }
            //如果存在字幕则加载
            if (this.V) {
                //如果播放器已存在，则认为是从newVideo函数发送过来的请求
                this.changeVideo();
                return;
            }
            if (this.vars["cktrack"]) {
                this.loadTrack();
            }
            if (this.supportVideo() && !this.vars["flashplayer"]) {
                this.getHtml5Video(); //判断浏览器支持的视频格式
            }
            var src = "",
                source = "",
                poster = "",
                loop = "",
                muted = "",
                autoplay = "",
                track = "",
                crossorigin = "";
            var video = v["video"];
            var i = 0;
            var vBg = this.ckStyle["background"]["backgroundColor"].replace(
                "0x",
                "#",
            );
            this.CD = this.getByElement(v["container"]);
            volume = v["volume"];
            if (this.isUndefined(this.CD)) {
                this.eject(this.errorList[6], v["container"]);
                return false;
            }

            //开始构建播放器容器
            this.V = undefined;
            var thisPd = null;
            if (v["h5container"] != "") {
                thisPd = this.getByElement(v["h5container"]);
                if (this.isUndefined(thisPd)) {
                    thisPd = null;
                }
            }
            var isVideoH5 = null; //isUndefined  thisPd
            if (v["playerID"] != "") {
                isVideoH5 = this.getByElement("#" + v["playerID"]);
                if (this.isUndefined(isVideoH5)) {
                    isVideoH5 = null;
                }
            }
            if (thisPd != null && isVideoH5 != null) {
                this.PD = thisPd; //PD:定义播放器容器对象全局变量
            } else {
                var playerID = "ckplayer-" + this.randomString();
                var playerDiv = document.createElement("div");
                playerDiv.className = playerID;
                this.CD.innerHTML = "";
                this.CD.appendChild(playerDiv);
                this.PD = playerDiv; //PD:定义播放器容器对象全局变量
            }
            this.css(this.CD, {
                backgroundColor: vBg,
                overflow: "hidden",
                position: "relative",
            });
            this.css(this.PD, {
                backgroundColor: vBg,
                width: "100%",
                height: "100%",
                fontFamily: this.fontFamily,
            });
            if (this.html5Video) {
                //如果支持HTML5-VIDEO则默认使用HTML5-VIDEO播放器

                //禁止播放器容器上鼠标选择文本
                this.PD.onselectstart = this.PD.ondrag = function () {
                    return false;
                };
                //播放器容器构建完成并且设置好样式
                //构建播放器
                if (this.VA.length == 1) {
                    this.videoTemp["src"] = decodeURIComponent(this.VA[0][0]);
                    src = ' src="' + this.videoTemp["src"] + '"';
                } else {
                    var videoArr = this.VA.slice(0);
                    videoArr = this.arrSort(videoArr);
                    for (i = 0; i < videoArr.length; i++) {
                        var type = "";
                        var va = videoArr[i];
                        if (va[1]) {
                            type = ' type="' + va[1] + '"';
                            if (type == ' type="video/m3u8"' || type == ' type="m3u8"') {
                                type = "";
                            }
                        }
                        source +=
                            '<source src="' + decodeURIComponent(va[0]) + '"' + type + ">";
                    }
                    this.videoTemp["source"] = source;
                }
                //分析视频地址结束
                if (v["autoplay"]) {
                    autoplay = ' autoplay="autoplay"';
                }
                if (v["poster"]) {
                    poster = ' poster="' + v["poster"] + '"';
                }
                if (v["loop"]) {
                    loop = ' loop="loop"';
                }
                if (v["muted"]) {
                    muted = ' muted="muted"';
                }
                if (v["seek"] > 0) {
                    this.needSeek = v["seek"];
                }
                if (v["track"] != null && v["cktrack"] == null) {
                    var trackArr = v["track"];
                    var trackDefault = "";
                    var defaultHave = false;
                    for (i = 0; i < trackArr.length; i++) {
                        var trackObj = trackArr[i];
                        if (trackObj["default"] && !defaultHave) {
                            trackDefault = " default";
                            defaultHave = true;
                        } else {
                            trackDefault = "";
                        }
                        track +=
                            '<track kind="' +
                            trackObj["kind"] +
                            '" src="' +
                            trackObj["src"] +
                            '" srclang="' +
                            trackObj["srclang"] +
                            '" label="' +
                            trackObj["label"] +
                            '"' +
                            trackDefault +
                            ">";
                    }
                }
                if (v["crossorigin"]) {
                    crossorigin = ' crossorigin="' + v["crossorigin"] + '"';
                }
                var autoLoad = this.ckConfig["config"]["autoLoad"];
                var preload = "";
                if (!autoLoad) {
                    preload = ' preload="meta"';
                }
                var vid = this.randomString();
                var controls = "";
                var mobileAutoFull = v["mobileAutoFull"];
                var mobileautofull = "";
                if (!mobileAutoFull) {
                    mobileautofull =
                        ' x-webkit-airplay="true" playsinline  webkit-playsinline="true"  x5-video-player-type="h5"';
                }
                if (this.isMobile()) {
                    controls = ' controls="controls"';
                }
                if (isVideoH5 != null && thisPd != null) {
                    this.V = isVideoH5;
                    if (v["poster"]) {
                        this.V.poster = v["poster"];
                    }
                } else {
                    var html = "";
                    if (!this.isM3u8) {
                        html =
                            '<video id="' +
                            vid +
                            '"' +
                            src +
                            ' controlslist="nodownload" width="100%" height="100%"' +
                            autoplay +
                            poster +
                            loop +
                            muted +
                            preload +
                            controls +
                            mobileautofull +
                            track +
                            crossorigin +
                            ">" +
                            source +
                            "</video>";
                    } else {
                        html =
                            '<video id="' +
                            vid +
                            '" controlslist="nodownload" width="100%" height="100%"' +
                            poster +
                            loop +
                            preload +
                            controls +
                            mobileautofull +
                            track +
                            crossorigin +
                            "></video>";
                    }
                    this.PD.innerHTML = html;
                    this.V = this.getByElement("#" + vid); //V：定义播放器对象全局变量
                }
                try {
                    this.V.volume = volume; //定义音量
                    if (this.playbackRateArr && this.vars["playbackrate"] > -1) {
                        if (this.vars["playbackrate"] < this.playbackRateArr.length) {
                            this.playbackRateDefault = this.vars["playbackrate"];
                        }
                        this.V.playbackRate =
                            this.playbackRateArr[this.playbackRateDefault][0]; //定义倍速
                    }
                } catch (error) {
                }
                this.css(this.V, {
                    backgroundColor: vBg,
                    width: "100%",
                    height: "100%",
                });
                if (this.isM3u8) {
                    var loadJsHandler = function () {
                        thisTemp.embedHls(thisTemp.VA[0][0], v["autoplay"]);
                    };
                    this.loadJs(this.ckplayerPath + "hls/hls.min.js", loadJsHandler);
                }
                this.css(this.V, "backgroundColor", vBg);
                //创建一个画布容器
                if (this.ckConfig["config"]["videoDrawImage"]) {
                    var canvasDiv = document.createElement("div");
                    this.PD.appendChild(canvasDiv);
                    this.MD = canvasDiv; //定义画布存储容器
                    this.css(this.MD, {
                        backgroundColor: vBg,
                        width: "100%",
                        height: "100%",
                        position: "absolute",
                        display: "none",
                        cursor: "pointer",
                        left: "0px",
                        top: "0px",
                        zIndex: "10",
                    });
                    var cvid = "ccanvas" + this.randomString();
                    this.MD.innerHTML = this.newCanvas(
                        cvid,
                        this.MD.offsetWidth,
                        this.MD.offsetHeight,
                    );
                    this.MDC = this.getByElement(cvid + "-canvas");
                    this.MDCX = this.MDC.getContext("2d");
                }
                this.playerType = "html5video";
                //播放器构建完成并且设置好样式
                //建立播放器的监听函数，包含操作监听及事件监听
                this.addVEvent();
                if (this.conBarShow) {
                    //根据清晰度的值构建清晰度切换按钮
                    this.definition();
                    if (
                        !this.vars["live"] &&
                        this.playbackRateArr &&
                        this.vars["playbackrate"] > -1
                    ) {
                        this.playbackRate();
                    }
                    if (v["autoplay"]) {
                        this.loadingStart(true);
                    }
                    this.subtitleSwitch();
                }
                this.playerLoad();
            } else {
                //如果不支持HTML5-VIDEO则调用flashplayer
                this.embedSWF();
            }
        },
        /*
			分析广告数据
		*/
        adAnalysis: function () {
            var thisTemp = this;
            var v = this.vars;
            var isAdvShow = [];
            var i = 0;
            if (
                v["advertisements"] != "" &&
                v["advertisements"].substr(0, 8) == "website:"
            ) {
                var ajaxObj = {
                    url: v["advertisements"].substr(8),
                    success: function (data) {
                        if (data) {
                            var newData = {};
                            var val = null;
                            //对广告进行分析
                            try {
                                if (
                                    !thisTemp.isUndefined(data["front"]) ||
                                    !thisTemp.isUndefined(data["pause"]) ||
                                    !thisTemp.isUndefined(data["end"]) ||
                                    !thisTemp.isUndefined(data["insert"]) ||
                                    !thisTemp.isUndefined(data["other"])
                                ) {
                                    val = thisTemp.arrayDel(data["front"]);
                                    if (!thisTemp.isUndefined(val)) {
                                        newData["front"] = val;
                                    }
                                    val = thisTemp.arrayDel(data["pause"]);
                                    if (!thisTemp.isUndefined(val)) {
                                        newData["pause"] = val;
                                    }
                                    val = thisTemp.arrayDel(data["insert"]);
                                    if (!thisTemp.isUndefined(val)) {
                                        newData["insert"] = val;
                                        if (!thisTemp.isUndefined(data["inserttime"])) {
                                            newData["inserttime"] = thisTemp.arrayInt(
                                                data["inserttime"],
                                            );
                                            isAdvShow = [];
                                            for (i = 0; i < newData["inserttime"].length; i++) {
                                                isAdvShow.push(false);
                                            }
                                            newData["insertPlay"] = isAdvShow;
                                        }
                                    }
                                    val = thisTemp.arrayDel(data["end"]);
                                    if (!thisTemp.isUndefined(val)) {
                                        newData["end"] = val;
                                    }
                                    val = thisTemp.arrayDel(data["other"]);
                                    if (!thisTemp.isUndefined(val)) {
                                        newData["other"] = val;
                                        isAdvShow = [];
                                        var arrTemp = [];
                                        for (i = 0; i < val.length; i++) {
                                            isAdvShow.push(false);
                                            arrTemp.push(parseInt("0" + val[i]["startTime"]));
                                        }
                                        newData["othertime"] = arrTemp;
                                        newData["otherPlay"] = isAdvShow;
                                    }
                                }
                            } catch (event) {
                                thisTemp.log(event);
                            }
                            thisTemp.advertisements = newData;
                            //对广告进行分析结束
                        }
                        thisTemp.getVideo();
                    },
                    error: function (data) {
                    },
                };
                this.ajax(ajaxObj);
            } else {
                //根据广告分析
                this.adAnalysisOne(
                    "front",
                    "adfront",
                    "adfronttime",
                    "adfrontlink",
                    "adfronttype",
                );
                this.adAnalysisOne(
                    "pause",
                    "adpause",
                    "adpausetime",
                    "adpauselink",
                    "adpausetype",
                );
                this.adAnalysisOne(
                    "insert",
                    "adinsert",
                    "adinserttime",
                    "adinsertlink",
                    "adinserttype",
                );
                this.adAnalysisOne(
                    "end",
                    "adend",
                    "adendtime",
                    "adendlink",
                    "adendtype",
                );
                if (!this.isUndefined(this.advertisements["insert"])) {
                    if (!this.isUndefined(v["inserttime"])) {
                        thisTemp.advertisements["inserttime"] = v["inserttime"];
                    }
                }
                if (!this.isUndefined(thisTemp.advertisements["inserttime"])) {
                    thisTemp.advertisements["inserttime"] = thisTemp.arrayInt(
                        thisTemp.advertisements["inserttime"],
                    );
                    isInsert = [];
                    for (i = 0; i < thisTemp.advertisements["inserttime"].length; i++) {
                        isInsert.push(false);
                    }
                    thisTemp.advertisements["insertPlay"] = isInsert;
                }
                thisTemp.getVideo();
            }
        },
        /*
			将广告数组数据里不是视频和图片的去除
		*/
        arrayDel: function (arr) {
            if (this.isUndefined(arr)) {
                return arr;
            }
            if (arr.length == 0) {
                return null;
            }
            var newArr = [];
            for (var i = 0; i < arr.length; i++) {
                var type = arr[i]["type"];
                if (type == "mp4" || type == "mov" || this.isStrImage(type)) {
                    newArr.push(arr[i]);
                }
            }
            if (newArr.length > 0) {
                return newArr;
            }
            return null;
        },
        /*分析单个类型的广告*/
        adAnalysisOne: function (adType, adName, adTime, adLink, adStype) {
            var v = this.vars;
            if (this.isUndefined(v[adName])) {
                v[adName] = "";
            }
            if (this.isUndefined(v[adTime])) {
                v[adTime] = "";
            }
            if (this.isUndefined(v[adLink])) {
                v[adLink] = "";
            }
            if (this.isUndefined(v[adStype])) {
                v[adStype] = "";
            }
            if (v[adName] != "") {
                var adList = [];
                var ad = v[adName].split(",");
                var adtime = v[adTime].split(",");
                var adlink = v[adLink].split(",");
                var adstype = v[adStype].split(",");
                var i = 0;
                if (ad.length > 0) {
                    var adLinkLen = adlink.length,
                        adTimeLen = adtime.length;
                    if (v[adLink] == "") {
                        adLinkLen = 0;
                        adlink = [];
                    }
                    if (v[adTime] == "") {
                        adTimeLen = 0;
                        adtime = [];
                    }
                    if (adLinkLen < ad.length) {
                        for (i = adLinkLen; i < ad.length; i++) {
                            adlink.push("");
                        }
                    }
                    if (adTimeLen < ad.length) {
                        for (i = adTimeLen; i < ad.length; i++) {
                            adtime.push("");
                        }
                    }
                    var adstypeLen = adstype.length;
                    if (v[adStype] == "") {
                        adstypeLen = 0;
                        adstype = [];
                    }
                    if (adstypeLen < ad.length) {
                        for (i = adstypeLen; i < ad.length; i++) {
                            adstype.push(this.getFileExt(ad[i]).replace(".", ""));
                        }
                    }
                    for (i = 0; i < ad.length; i++) {
                        var type = adstype[i];
                        if (type == "mp4" || type == "mov" || this.isStrImage(type)) {
                            var obj = {
                                file: ad[i],
                                type: type,
                                time:
                                    parseInt(adtime[i]) > 0
                                        ? parseInt(adtime[i])
                                        : this.ckStyle["advertisement"]["time"],
                                link: adlink[i],
                            };
                            adList.push(obj);
                        }
                    }
                    if (this.isUndefined(this.advertisements)) {
                        this.advertisements = {};
                    }
                    if (adList.length > 0) {
                        this.advertisements[adType] = adList;
                    }
                }
            }
        },
        /*
			内部函数
			发送播放器加载成功的消息
		*/
        playerLoad: function () {
            var thisTemp = this;
            if (this.isFirst) {
                this.isFirst = false;
                setTimeout(function () {
                    thisTemp.loadedHandler();
                }, 1);
            }
        },
        /*
			内部函数
			建立播放器的监听函数，包含操作监听及事件监听
		*/
        addVEvent: function () {
            var thisTemp = this;
            var duration = 0;
            //监听视频单击事件
            var eventVideoClick = function (event) {
                thisTemp.videoClickXy = {x: event.clientX, y: event.clientY};
                thisTemp.videoClick();
            };
            this.addListenerInside("click", eventVideoClick);
            this.addListenerInside("click", eventVideoClick, this.MDC);
            //延迟计算加载失败事件
            this.timerErrorFun();
            //监听视频加载到元数据事件
            var eventJudgeIsLive = function (event) {
                thisTemp.sendJS("loadedmetadata");
                if (
                    thisTemp.varType(thisTemp.V.duration) == "number" &&
                    thisTemp.V.duration > 1
                ) {
                    duration = thisTemp.V.duration;
                    if (!duration) {
                        if (thisTemp.vars["duration"] > 0) {
                            duration = thisTemp.vars["duration"];
                        }
                    }
                    if (thisTemp.vars["forceduration"] > 0) {
                        duration = thisTemp.vars["forceduration"];
                    }
                    thisTemp.sendJS("duration", duration);
                    thisTemp.formatInserttime(duration);
                    if (thisTemp.adPlayerPlay) {
                        thisTemp.advertisementsTime(duration + 1);
                    }
                    thisTemp.durationSendJS = true;
                }
                if (thisTemp.conBarShow) {
                    thisTemp.V.controls = null;
                    thisTemp.videoCss();
                }
                thisTemp.judgeIsLive();
            };
            //监听视频播放事件
            var eventPlaying = function (event) {
                thisTemp.playingHandler();
                thisTemp.sendJS("play");
                thisTemp.sendJS("paused", false);
                if (
                    !thisTemp.durationSendJS &&
                    thisTemp.varType(thisTemp.V.duration) == "number" &&
                    thisTemp.V.duration > 0
                ) {
                    duration = thisTemp.V.duration;
                    if (!duration) {
                        if (thisTemp.vars["duration"] > 0) {
                            duration = thisTemp.vars["duration"];
                        }
                    }
                    if (thisTemp.vars["forceduration"] > 0) {
                        duration = thisTemp.vars["forceduration"];
                    }
                    thisTemp.durationSendJS = true;
                    thisTemp.sendJS("duration", duration);
                    thisTemp.formatInserttime(duration);
                }
            };
            this.addListenerInside("playing", eventPlaying);
            //监听视频暂停事件
            var eventPause = function (event) {
                thisTemp.pauseHandler();
                thisTemp.sendJS("pause");
                thisTemp.sendJS("paused", true);
            };
            this.addListenerInside("pause", eventPause);
            //监听视频播放结束事件
            var eventEnded = function (event) {
                thisTemp.endedHandler();
            };
            this.addListenerInside("ended", eventEnded);
            //监听视频播放时间事件
            var eventTimeupdate = function (event) {
                if (thisTemp.loadingShow) {
                    thisTemp.loadingStart(false);
                }
                if (thisTemp.time) {
                    if (!thisTemp.adPlayerPlay) {
                        thisTemp.sendJS("time", thisTemp.time);
                        //监听中间插入广告是否需要播放
                        if (!thisTemp.isUndefined(thisTemp.advertisements["insert"])) {
                            thisTemp.checkAdInsert(thisTemp.time);
                        }
                        //监听其它广告
                        if (!thisTemp.isUndefined(thisTemp.advertisements["other"])) {
                            thisTemp.checkAdOther(thisTemp.time);
                        }
                        if (thisTemp.time < 3 && thisTemp.adReset) {
                            thisTemp.adReset = false;
                            thisTemp.endedAdReset();
                        }
                    } else {
                        //如果是广告则进行广告倒计时
                        thisTemp.adPlayerTimeHandler(thisTemp.time);
                    }
                }
            };
            this.addListenerInside("timeupdate", eventTimeupdate);
            //监听视频缓冲事件
            var eventWaiting = function (event) {
                thisTemp.loadingStart(true);
            };
            this.addListenerInside("waiting", eventWaiting);
            //监听视频seek开始事件
            var eventSeeking = function (event) {
                thisTemp.sendJS("seek", "start");
            };
            this.addListenerInside("seeking", eventSeeking);
            //监听视频seek结束事件
            var eventSeeked = function (event) {
                thisTemp.seekedHandler();
                thisTemp.sendJS("seek", "ended");
            };
            this.addListenerInside("seeked", eventSeeked);
            //监听视频音量
            var eventVolumeChange = function (event) {
                try {
                    thisTemp.volumechangeHandler();
                    thisTemp.sendJS("volume", thisTemp.volume || thisTemp.V.volume);
                } catch (event) {
                }
            };
            this.addListenerInside("volumechange", eventVolumeChange);
            //监听全屏事件
            var eventFullChange = function (event) {
                var fullState =
                    document.fullScreen ||
                    document.mozFullScreen ||
                    document.webkitIsFullScreen;
                thisTemp.sendJS("full", fullState);
            };
            this.addListenerInside("fullscreenchange", eventFullChange);
            this.addListenerInside("webkitfullscreenchange", eventFullChange);
            this.addListenerInside("mozfullscreenchange", eventFullChange);
            //建立界面
            if (this.conBarShow) {
                this.interFace();
            }
            this.addListenerInside("loadedmetadata", eventJudgeIsLive);
        },
        /*
			内部函数
			重置界面元素
		*/
        resetPlayer: function () {
            this.timeTextHandler();
            if (this.conBarShow) {
                this.timeProgress(0, 1); //改变时间进度条宽
                this.changeLoad(0);
                this.initPlayPause(); //判断显示播放或暂停按钮
                this.definition(); //构建清晰度按钮
                this.deletePrompt(); //删除提示点
                this.deletePreview(); //删除预览图
                this.trackHide(); //重置字幕
                this.resetTrack();
                this.trackElement = [];
                this.track = [];
            }
        },
        /*
			内部函数
			构建界面元素
		 */
        interFace: function () {
            this.conBarShow = true;
            var thisTemp = this;
            var html = ""; //控制栏内容
            var i = 0;
            var thisStyle = this.ckStyle;
            var styleC = thisStyle["controlBar"];
            var styleCB = styleC["button"];
            var styleAS = thisStyle["advertisement"];
            var styleDF = styleC["definition"];
            var bWidth = 38; //按钮的宽
            var timeInto = this.formatTime(
                0,
                this.vars["duration"],
                this.ckLanguage["vod"],
            ); //时间显示框默认显示内容
            /*
				构建一些PD（播放器容器）里使用的元素
			*/
            /*
			 	构建播放器内的元素
			*/
            this.CB = {menu: null};
            var divEle = {
                controlBarBg: null,
                controlBar: null,
                pauseCenter: null,
                errorText: null,
                promptBg: null,
                prompt: null,
                promptTriangle: null,
                definitionP: null,
                playbackrateP: null,
                subtitlesP: null,
                loading: null,
                logo: null,
                adBackground: null,
                adElement: null,
                adLink: null,
                adPauseClose: null,
                adTime: null,
                adTimeText: null,
                adMute: null,
                adEscMute: null,
                adSkip: null,
                adSkipText: null,
                adSkipButton: null,
            };
            var k = "";
            for (k in divEle) {
                this.CB[k] = divEle[k];
                this.CB[k] = document.createElement("div");
                this.PD.appendChild(this.CB[k]);
            }
            /*
				构建鼠标右键容器
			*/
            this.CB["menu"] = document.createElement("div");
            this.body.appendChild(this.CB["menu"]);
            if (this.vars["live"]) {
                //如果是直播，时间显示文本框里显示当前系统时间
                timeInto = this.formatTime(0, 0, this.ckLanguage["live"]); //时间显示框默认显示内容
            }
            /*
				构建控制栏的按钮
			*/
            divEle = {
                play: null,
                pause: null,
                mute: null,
                escMute: null,
                full: null,
                escFull: null,
                definition: null,
                playbackrate: null,
                subtitles: null,
            };
            for (k in divEle) {
                this.CB[k] = divEle[k];
                this.CB[k] = document.createElement("div");
                if (!this.isUndefined(this.ckLanguage["buttonOver"][k])) {
                    this.CB[k].dataset.title = this.ckLanguage["buttonOver"][k];
                }
                this.CB["controlBar"].appendChild(this.CB[k]);
            }
            divEle = {
                timeProgressBg: null,
                timeBoBg: null,
                volume: null,
                timeText: null,
            };
            for (k in divEle) {
                this.CB[k] = divEle[k];
                this.CB[k] = document.createElement("div");
                this.CB["controlBar"].appendChild(this.CB[k]);
            }
            this.CB["timeText"].innerHTML = timeInto; //初始化时间
            divEle = {
                loadProgress: null,
                timeProgress: null,
            };
            for (k in divEle) {
                this.CB[k] = divEle[k];
                this.CB[k] = document.createElement("div");
                this.CB["timeProgressBg"].appendChild(this.CB[k]);
            }
            this.CB["timeButton"] = document.createElement("div");
            this.CB["timeBoBg"].appendChild(this.CB["timeButton"]);
            divEle = {
                volumeBg: null,
                volumeBO: null,
            };
            for (k in divEle) {
                this.CB[k] = divEle[k];
                this.CB[k] = document.createElement("div");
                this.CB["volume"].appendChild(this.CB[k]);
            }
            this.CB["volumeUp"] = document.createElement("div");
            this.CB["volumeBg"].appendChild(this.CB["volumeUp"]);
            //构建loading图标
            var imgTemp = null;
            var imgFile = "";
            var imgFile = thisStyle["loading"]["file"];
            if (!this.isUndefined(thisStyle["loading"]["fileH5"])) {
                imgFile = thisStyle["loading"]["fileH5"];
            }
            if (imgFile) {
                imgTemp = document.createElement("img");
                imgTemp.src = imgFile;
                imgTemp.border = 0;
                this.CB["loading"].appendChild(imgTemp);
            }
            //构建logo图标
            imgFile = thisStyle["logo"]["file"];
            if (!this.isUndefined(thisStyle["logo"]["fileH5"])) {
                imgFile = thisStyle["logo"]["fileH5"];
            }
            //定义界面元素的样式
            if (this.ckConfig["config"]["buttonMode"]["player"]) {
                this.css(this.PD, {cursor: "pointer"});
            }
            //控制栏背景
            this.controlBar(); //改变控制栏
            var cssTemp = null;
            //定义提示语的样式
            var promptCss = thisStyle["prompt"];
            cssTemp = this.getEleCss(promptCss, {
                overflow: "hidden",
                zIndex: 900,
                display: "none",
            });
            this.css(this.CB["promptBg"], cssTemp);
            this.css(this.CB["promptBg"], "padding", "0px");
            cssTemp["backgroundColor"] = "";
            cssTemp["border"] = "";
            cssTemp["borderRadius"] = "";
            cssTemp["whiteSpace"] = "nowrap";
            this.css(this.CB["prompt"], cssTemp);
            //定义提示语下方的三解形的样式
            cssTemp = {
                width: 0,
                height: 0,
                borderLeft: promptCss["triangleWidth"] * 0.5 + "px solid transparent",
                borderRight: promptCss["triangleWidth"] * 0.5 + "px solid transparent",
                borderTop:
                    promptCss["triangleHeight"] +
                    "px solid " +
                    promptCss["triangleBackgroundColor"].replace("0x", "#"),
                overflow: "hidden",
                opacity: promptCss["triangleAlpha"],
                filter: "alpha(opacity:" + promptCss["triangleAlpha"] + ")",
                position: "absolute",
                left: "0px",
                top: "0px",
                zIndex: 900,
                display: "none",
            };
            this.css(this.CB["promptTriangle"], cssTemp);
            this.elementCoordinate(); //中间播放按钮，出错文本框，logo，loading
            this.css(
                [this.CB["pauseCenter"], this.CB["loading"], this.CB["errorText"]],
                "display",
                "none",
            );
            this.carbarButton(); //控制栏按钮
            this.playerCustom(); //播放器界面自定义元件
            this.carbarCustom(); //控制栏自定义元件
            this.timeProgressDefault(); //进度条默认样式
            this.videoCss(); //计算video的宽高和位置
            //初始化判断播放/暂停按钮隐藏项
            this.initPlayPause();
            if (this.vars["volume"] > 0) {
                this.css(this.CB["escMute"], "display", "none");
            } else {
                this.css(this.CB["mute"], "display", "none");
            }
            if (!this.ckConfig["config"]["mobileVolumeBarShow"] && this.isMobile()) {
                this.css([this.CB["mute"], this.CB["escMute"], this.CB["volume"]], {
                    display: "none",
                });
            }
            this.css(this.CB["escFull"], "display", "none");
            //设置广告背景层样式
            var cssObj = {
                align: "top",
                vAlign: "left",
                width: "100%",
                height: "100%",
                offsetX: 0,
                offsetY: 0,
                zIndex: 910,
                display: "none",
            };
            cssTemp = this.getEleCss(styleAS["background"], cssObj);
            this.css(this.CB["adBackground"], cssTemp);
            this.css(this.CB["adElement"], {
                position: "absolute",
                overflow: "hidden",
                top: "0px",
                zIndex: 911,
                float: "center",
                display: "none",
            });
            //广告控制各元素样式，用一个函数单独定义，这样在播放器尺寸变化时可以重新设置样式
            this.advertisementStyle();
            //初始化广告控制各元素-隐藏
            this.css(
                [
                    this.CB["adTime"],
                    this.CB["adTimeText"],
                    this.CB["adMute"],
                    this.CB["adEscMute"],
                    this.CB["adSkip"],
                    this.CB["adSkipText"],
                    this.CB["adSkipButton"],
                    this.CB["adLink"],
                    this.CB["adPauseClose"],
                ],
                "display",
                "none",
            );
            //定义鼠标经过控制栏只显示完整的进度条，鼠标离开进度条则显示简单的进度条
            var timeProgressOut = function (event) {
                thisTemp.timeProgressMouseOut();
            };
            this.addListenerInside("mouseout", timeProgressOut, this.CB["timeBoBg"]);
            var timeProgressOver = function (event) {
                thisTemp.timeProgressDefault();
            };
            this.addListenerInside(
                "mouseover",
                timeProgressOver,
                this.CB["controlBar"],
            );
            //定义各按钮鼠标经过时的切换样式
            this.buttonEventFun(this.CB["play"], styleCB["play"]); //播放按钮
            this.buttonEventFun(this.CB["pause"], styleCB["pause"]); //暂停按钮
            this.buttonEventFun(this.CB["mute"], styleCB["mute"]); //静音按钮
            this.buttonEventFun(this.CB["escMute"], styleCB["escMute"]); //恢复音量按钮
            this.buttonEventFun(this.CB["full"], styleCB["full"]); //全屏按钮
            this.buttonEventFun(this.CB["escFull"], styleCB["escFull"]); //退出全屏按钮
            this.buttonEventFun(this.CB["adMute"], styleAS["muteButton"]); //广告静音按钮
            this.buttonEventFun(this.CB["adEscMute"], styleAS["escMuteButton"]); //恢复广告音量按钮
            this.buttonEventFun(this.CB["adSkipButton"], styleAS["skipAdButton"]); //跳过广告按钮
            this.buttonEventFun(this.CB["adLink"], styleAS["adLinkButton"]); //广告查看详情按钮
            this.buttonEventFun(this.CB["adPauseClose"], styleAS["closeButton"]); //播放暂停时的广告的关闭按钮
            this.buttonEventFun(this.CB["pauseCenter"], thisStyle["centerPlay"]); //播放器中间暂停时的播放按钮
            this.buttonEventFun(
                this.CB["volumeBO"],
                styleC["volumeSchedule"]["button"],
            ); //音量调节框按钮样式
            this.buttonEventFun(
                this.CB["timeButton"],
                styleC["timeSchedule"]["button"],
            ); //时间进度调节框按钮样式

            this.addButtonEvent(); //注册按钮及音量调节，进度操作事件
            this.controlBarHide(); //单独注册控制栏隐藏事件
            this.newMenu(); //设置右键的样式和事件
            this.keypress(); //注册键盘事件
            //初始化音量调节框
            this.changeVolume(this.vars["volume"]);
            setTimeout(function () {
                thisTemp.elementCoordinate(); //调整中间暂停按钮/loading的位置/error的位置
            }, 100);
            this.checkBarWidth();
            var resize = function () {
                thisTemp.log("window.resize");
                thisTemp.playerResize();
            };
            var MutationObserver =
                window.MutationObserver ||
                window.WebKitMutationObserver ||
                window.MozMutationObserver;
            var observer = new MutationObserver(function () {
                thisTemp.log("video.resize");
                var cdW = parseInt(thisTemp.css(thisTemp.CD, "width")),
                    cdH = parseInt(thisTemp.css(thisTemp.CD, "height"));
                if (cdW != thisTemp.cdWH["w"] || cdH != thisTemp.cdWH["h"]) {
                    thisTemp.cdWH = {
                        w: cdW,
                        h: cdH,
                    };
                    thisTemp.changeSize(cdW, cdH);
                }
            });
            observer.observe(this.CD, {
                attributes: true,
                attributeFilter: ["style"],
                attributeOldValue: true,
            });
            this.addListenerInside("resize", resize, window);
        },
        /*
			内部函数
			进间进度条默认样式
		*/
        timeProgressDefault: function () {
            var styleCT = this.ckStyle["controlBar"]["timeSchedule"];
            var cssObj = this.newObj(styleCT["default"]);
            var loadBackImg = cssObj["loadProgressImg"],
                playBackImg = cssObj["playProgressImg"];
            var cssTemp = null;
            this.css(this.CB["timeBoBg"], "display", "block");
            //时间进度条背景容器
            cssTemp = this.getEleCss(
                this.newObj(cssObj),
                {
                    overflow: "hidden",
                    zIndex: 2,
                },
                this.CB["controlBarBg"],
            );
            this.css(this.CB["timeProgressBg"], cssTemp);
            //加载进度
            cssObj = {
                align: "left",
                vAlign: "top",
                width: 1,
                height: cssObj["height"],
                backgroundImg: loadBackImg,
            };
            //加载进度和时间进度
            if (this.CB["loadProgress"].offsetWidth > 1) {
                cssObj["width"] = this.CB["loadProgress"].offsetWidth;
            }
            cssTemp = this.getEleCss(
                this.newObj(cssObj),
                {
                    overflow: "hidden",
                    zIndex: 1,
                },
                this.CB["timeProgressBg"],
            );
            this.css(this.CB["loadProgress"], cssTemp);
            cssObj["width"] = 0;
            if (
                this.CB["timeProgress"].offsetWidth > 1 &&
                parseInt(this.css(this.CB["timeButton"], "left")) > 0
            ) {
                cssObj["width"] = this.CB["timeProgress"].offsetWidth;
            }
            cssObj["backgroundImg"] = playBackImg;
            cssTemp = this.getEleCss(cssObj, {overflow: "hidden", zIndex: 2});
            this.css(this.CB["timeProgress"], cssTemp);
            //时间进度按钮容器
            cssTemp = this.getEleCss(
                styleCT["buttonContainer"],
                {
                    position: "absolute",
                    overflow: "hidden",
                    zIndex: 3,
                },
                this.CB["controlBar"],
            );
            if (this.ckConfig["config"]["buttonMode"]["timeSchedule"]) {
                cssTemp["cursor"] = "pointer";
            }
            this.css(this.CB["timeBoBg"], cssTemp);
            //时间进度按钮
            cssTemp = this.getEleCss(
                styleCT["button"],
                {
                    cursor: "pointer",
                    overflow: "hidden",
                    zIndex: 4,
                },
                this.CB["timeBoBg"],
            );
            this.css(this.CB["timeButton"], cssTemp);
        },
        /*
			内部函数
			进间进度条鼠标离开样式
		*/
        timeProgressMouseOut: function () {
            var styleCT = this.ckStyle["controlBar"]["timeSchedule"];
            var cssObj = this.newObj(styleCT["mouseOut"]);
            var loadBackImg = cssObj["loadProgressImg"],
                playBackImg = cssObj["playProgressImg"];
            var cssTemp = null;
            this.css(this.CB["timeBoBg"], "display", "block");
            //时间进度条背景容器
            cssTemp = this.getEleCss(
                this.newObj(cssObj),
                {
                    overflow: "hidden",
                    zIndex: 2,
                },
                this.CB["controlBarBg"],
            );
            this.css(this.CB["timeProgressBg"], cssTemp);
            //加载进度
            cssObj = {
                align: "left",
                vAlign: "top",
                width: 1,
                height: cssObj["height"],
                backgroundImg: loadBackImg,
            };
            //加载进度和时间进度
            if (this.CB["loadProgress"].offsetWidth > 1) {
                cssObj["width"] = this.CB["loadProgress"].offsetWidth;
            }
            cssTemp = this.getEleCss(
                this.newObj(cssObj),
                {
                    overflow: "hidden",
                    zIndex: 1,
                },
                this.CB["timeProgressBg"],
            );
            this.css(this.CB["loadProgress"], cssTemp);
            cssObj["width"] = 1;
            if (
                this.CB["timeProgress"].offsetWidth > 1 &&
                parseInt(this.css(this.CB["timeButton"], "left")) > 0
            ) {
                cssObj["width"] = this.CB["timeProgress"].offsetWidth;
                cssObj["backgroundImg"] = playBackImg;
            }
            cssTemp = this.getEleCss(cssObj, {overflow: "hidden", zIndex: 2});
            this.css(this.CB["timeProgress"], cssTemp);
            this.css(this.CB["timeBoBg"], "display", "none");
        },
        /*
			统一注册按钮鼠标经过和离开时的切换动作
		*/
        buttonEventFun: function (ele, cssEle) {
            var thisTemp = this;
            var overFun = function (event) {
                thisTemp.css(ele, {
                    backgroundImage: "url(" + cssEle["mouseOver"] + ")",
                });
                thisTemp.promptShow(ele);
            };
            var outFun = function (event) {
                thisTemp.css(ele, {
                    backgroundImage: "url(" + cssEle["mouseOut"] + ")",
                });
                thisTemp.promptShow(false);
            };
            outFun();
            this.addListenerInside("mouseover", overFun, ele);
            this.addListenerInside("mouseout", outFun, ele);
            if (!this.isUndefined(cssEle["clickEvent"])) {
                var clickFun = function (event) {
                    thisTemp.runFunction(cssEle["clickEvent"]);
                };
                this.addListenerInside("click", clickFun, ele);
            }
        },
        /*
			内部函数
			格式化样式用的数字
		*/
        formatNumPx: function (str, z) {
            if (!str) {
                return 0;
            }
            if (str.toString().indexOf("%") > -1) {
                //说明是根据百分比来计算
                if (!this.isUndefined(z)) {
                    //如果有值
                    return parseInt(str) * z * 0.01 + "px";
                }
                return str;
            } else {
                return str + "px";
            }
        },
        /*
			内部函数
			格式化样式用的数字，返回类型必需是数字或百分比
		*/
        formatZToNum: function (str, z) {
            if (!str) {
                return 0;
            }
            if (str.toString().indexOf("%") > -1) {
                //说明是根据百分比来计算
                if (!this.isUndefined(z)) {
                    //如果有值
                    return parseInt(str) * z * 0.01;
                }
                return str;
            } else {
                return str;
            }
        },
        /*
			内部函数
			对对象进行深度复制
		*/
        newObj: function (obj) {
            if (this.isUndefined(obj)) {
                return obj;
            }
            var str,
                newobj = {}; //constructor 属性返回对创建此对象的数组函数的引用。创建相同类型的空数据
            if (this.varType(obj) != "object") {
                return obj;
            } else {
                for (var k in obj) {
                    if (this.isUndefined(obj[k])) {
                        newobj[k] = obj[k];
                    } else {
                        if (this.varType(obj[k]) == "object") {
                            //判断对象的这条属性是否为对象
                            newobj[k] = this.newObj(obj[k]); //若是对象进行嵌套调用
                        } else {
                            newobj[k] = obj[k];
                        }
                    }
                }
            }
            return newobj; //返回深度克隆后的对象
        },
        /*
			内部函数
			统一的显示图片
		*/
        loadImgBg: function (eleid, obj) {
            this.css(this.getByElement(eleid), {
                backgroundImage: "url(" + obj + ")",
            });
        },
        /*
			内部函数
			格式化css
			eleObj=样式,
			supplement=补充样式,
			rrEle=参考对象，
			该函数强制使用position定位的元素
		*/
        getEleCss: function (eleObj, supplement, rrEle) {
            var eleName = null;
            var pdW = this.PD.offsetWidth,
                pdH = this.PD.offsetHeight;
            if (rrEle) {
                pdW = rrEle.offsetWidth;
                pdH = rrEle.offsetHeight;
            }
            if (this.isUndefined(eleObj)) {
                return null;
            }
            eleName = this.newObj(eleObj);
            var cssObject = {};
            if (!this.isUndefined(eleName["width"])) {
                cssObject["width"] = this.formatZToNum(eleName["width"], pdW) + "px";
            }
            if (!this.isUndefined(eleName["height"])) {
                cssObject["height"] = this.formatZToNum(eleName["height"], pdH) + "px";
            }
            if (!this.isUndefined(eleName["background"])) {
                var bg = eleName["background"];
                if (!this.isUndefined(bg["backgroundColor"])) {
                    cssObject["backgroundColor"] = bg["backgroundColor"].replace(
                        "0x",
                        "#",
                    );
                }
                if (!this.isUndefined(bg["backgroundImg"])) {
                    cssObject["backgroundImage"] = "url(" + bg["backgroundImg"] + ")";
                }
                if (!this.isUndefined(bg["alpha"])) {
                    cssObject["filter"] = "alpha(opacity:" + bg["alpha"] + ")";
                    cssObject["opacity"] = bg["alpha"];
                }
            }
            if (!this.isUndefined(eleName["backgroundColor"])) {
                cssObject["backgroundColor"] = eleName["backgroundColor"].replace(
                    "0x",
                    "#",
                );
            }
            if (!this.isUndefined(eleName["backgroundImg"])) {
                cssObject["backgroundImage"] = "url(" + eleName["backgroundImg"] + ")";
            }
            if (!this.isUndefined(eleName["color"])) {
                cssObject["color"] = eleName["color"].replace("0x", "#");
            }
            if (!this.isUndefined(eleName["font"])) {
                cssObject["fontFamily"] = eleName["font"];
            }
            if (!this.isUndefined(eleName["size"])) {
                cssObject["fontSize"] = eleName["size"] + "px";
            }
            if (!this.isUndefined(eleName["alpha"])) {
                cssObject["filter"] = "alpha(opacity:" + eleName["alpha"] + ")";
                cssObject["opacity"] = eleName["alpha"];
            }
            if (!this.isUndefined(eleName["lineHeight"])) {
                cssObject["lineHeight"] = eleName["lineHeight"] + "px";
            }
            if (!this.isUndefined(eleName["textAlign"])) {
                cssObject["textAlign"] = eleName["textAlign"];
            }
            if (!this.isUndefined(eleName["borderRadius"])) {
                cssObject["borderRadius"] = eleName["borderRadius"] + "px";
            }
            if (!this.isUndefined(eleName["radius"])) {
                cssObject["borderRadius"] = eleName["radius"] + "px";
            }
            if (!this.isUndefined(eleName["padding"])) {
                cssObject["padding"] = eleName["padding"] + "px";
            }
            if (!this.isUndefined(eleName["paddingLeft"])) {
                cssObject["paddingLeft"] = eleName["paddingLeft"] + "px";
            }
            if (!this.isUndefined(eleName["paddingRight"])) {
                cssObject["paddingRight"] = eleName["paddingRight"] + "px";
            }
            if (!this.isUndefined(eleName["paddingTop"])) {
                cssObject["paddingTop"] = eleName["paddingTop"] + "px";
            }
            if (!this.isUndefined(eleName["paddingBottom"])) {
                cssObject["paddingBottom"] = eleName["paddingBottom"] + "px";
            }
            if (!this.isUndefined(eleName["margin"])) {
                cssObject["margin"] = eleName["margin"] + "px";
            }
            if (!this.isUndefined(eleName["marginLeft"])) {
                cssObject["marginLeft"] = eleName["marginLeft"] + "px";
            }
            if (!this.isUndefined(eleName["marginRight"])) {
                cssObject["marginRight"] = eleName["marginRight"] + "px";
            }
            if (!this.isUndefined(eleName["marginTop"])) {
                cssObject["marginTop"] = eleName["marginTop"] + "px";
            }
            if (!this.isUndefined(eleName["marginBottom"])) {
                cssObject["marginBottom"] = eleName["marginBottom"] + "px";
            }
            if (
                !this.isUndefined(eleName["border"]) &&
                !this.isUndefined(eleName["borderColor"])
            ) {
                cssObject["border"] =
                    eleName["border"] +
                    "px solid " +
                    eleName["borderColor"].replace("0x", "#");
            }
            if (
                !this.isUndefined(eleName["borderLeft"]) &&
                !this.isUndefined(eleName["borderLeftColor"])
            ) {
                cssObject["borderLeft"] =
                    eleName["borderLeft"] +
                    "px solid " +
                    eleName["borderLeftColor"].replace("0x", "#");
            }
            if (
                !this.isUndefined(eleName["borderRight"]) &&
                !this.isUndefined(eleName["borderRightColor"])
            ) {
                cssObject["borderRight"] =
                    eleName["borderRight"] +
                    "px solid " +
                    eleName["borderRightColor"].replace("0x", "#");
            }
            if (
                !this.isUndefined(eleName["borderTop"]) &&
                !this.isUndefined(eleName["borderTopColor"])
            ) {
                cssObject["borderTop"] =
                    eleName["borderTop"] +
                    "px solid " +
                    eleName["borderTopColor"].replace("0x", "#");
            }
            if (
                !this.isUndefined(eleName["borderBottom"]) &&
                !this.isUndefined(eleName["borderBottomColor"])
            ) {
                cssObject["borderBottom"] =
                    eleName["borderBottom"] +
                    "px solid " +
                    eleName["borderBottomColor"].replace("0x", "#");
            }
            if (!this.isUndefined(supplement)) {
                for (var k in supplement) {
                    cssObject[k] = supplement[k];
                }
            }
            cssObject["position"] = "absolute";
            var left = -10000,
                top = -10000,
                right = -10000,
                bottom = -10000;
            var offsetX = 0,
                offsetY = 0;
            if (!this.isUndefined(eleName["offsetX"])) {
                offsetX = eleName["offsetX"];
            }
            if (!this.isUndefined(eleName["marginX"])) {
                offsetX = eleName["marginX"];
            }
            if (!this.isUndefined(eleName["offsetY"])) {
                offsetY = eleName["offsetY"];
            }
            if (!this.isUndefined(eleName["marginY"])) {
                offsetY = eleName["marginY"];
            }
            offsetX = this.formatZToNum(offsetX, pdW);
            offsetY = this.formatZToNum(offsetY, pdH);
            if (!this.isUndefined(eleName["align"])) {
                left = 0;
                switch (eleName["align"]) {
                    case "left":
                        left = offsetX;
                        break;
                    case "center":
                        left = pdW * 0.5 + offsetX;
                        break;
                    case "right":
                        left = pdW + offsetX;
                        break;
                    case "right2":
                        left = -10000;
                        right = offsetX;
                        break;
                }
            }
            if (!this.isUndefined(eleName["vAlign"])) {
                top = 0;
                switch (eleName["vAlign"]) {
                    case "top":
                        top = offsetY;
                        break;
                    case "middle":
                        top = pdH * 0.5 + offsetY;
                        break;
                    case "bottom":
                        top = pdH + offsetY;
                        break;
                    case "bottom2":
                        top = -10000;
                        bottom = offsetY;

                        break;
                }
            }
            if (left > -10000) {
                cssObject["left"] = left + "px";
            }
            if (right > -10000) {
                cssObject["right"] = right + "px";
            }
            if (top > -10000) {
                cssObject["top"] = top + "px";
            }
            if (bottom > -10000) {
                cssObject["bottom"] = bottom + "px";
            }
            return cssObject;
        },
        /*
			内部函数
			创建按钮，使用canvas画布
		*/
        newCanvas: function (id, width, height) {
            return (
                '<canvas class="' +
                id +
                '-canvas" width="' +
                width +
                '" height="' +
                height +
                '"></canvas>'
            );
        },
        /*
			内部函数
			注册按钮，音量调节框，进度操作框事件
		*/
        addButtonEvent: function () {
            var thisTemp = this;
            //定义按钮的单击事件

            //定义各个按钮的鼠标经过/离开事件
            var promptHide = function (event) {
                thisTemp.promptShow(false);
            };
            var definitionOver = function (event) {
                thisTemp.promptShow(thisTemp.CB["definition"]);
            };
            this.addListenerInside(
                "mouseover",
                definitionOver,
                this.CB["definition"],
            );
            this.addListenerInside("mouseout", promptHide, this.CB["definition"]);
            var playbackrateOver = function (event) {
                thisTemp.promptShow(thisTemp.CB["playbackrate"]);
            };
            this.addListenerInside(
                "mouseover",
                playbackrateOver,
                this.CB["playbackrate"],
            );
            this.addListenerInside("mouseout", promptHide, this.CB["playbackrate"]);
            var subtitlesOver = function (event) {
                thisTemp.promptShow(thisTemp.CB["subtitles"]);
            };
            this.addListenerInside("mouseover", subtitlesOver, this.CB["subtitles"]);
            this.addListenerInside("mouseout", promptHide, this.CB["subtitles"]);
            //定义音量和进度按钮的滑块事件
            var volumePrompt = function (vol) {
                var volumeBOXY = thisTemp.getCoor(thisTemp.CB["volumeBO"]);
                var promptObj = {
                    title: thisTemp.ckLanguage["volumeSliderOver"].replace(
                        "[$volume]",
                        vol,
                    ),
                    x: volumeBOXY["x"] + thisTemp.CB["volumeBO"].offsetWidth * 0.5,
                    y: volumeBOXY["y"],
                };
                thisTemp.promptShow(false, promptObj);
            };
            var volumeObj = {
                slider: this.CB["volumeBO"],
                follow: this.CB["volumeUp"],
                refer: this.CB["volumeBg"],
                grossValue: "volume",
                pd: true,
                startFun: function (vol) {
                },
                monitorFun: function (vol) {
                    thisTemp.changeVolume(vol * 0.01, false, false);
                    volumePrompt(vol);
                },
                endFun: function (vol) {
                },
                overFun: function (vol) {
                    volumePrompt(vol);
                },
            };
            this.slider(volumeObj);
            var volumeClickObj = {
                refer: this.CB["volumeBg"],
                grossValue: "volume",
                fun: function (vol) {
                    thisTemp.changeVolume(vol * 0.01, true, true);
                },
            };
            this.progressClick(volumeClickObj);
            this.timeButtonMouseDown(); //用单击的函数来判断是否需要建立控制栏监听
            //鼠标经过/离开音量调节框时的
            var volumeBgMove = function (event) {
                var volumeBgXY = thisTemp.getCoor(thisTemp.CB["volumeBg"]);
                var eventX = thisTemp.client(event)["x"];
                var eventVolume = parseInt(
                    ((eventX - volumeBgXY["x"]) * 100) /
                    thisTemp.CB["volumeBg"].offsetWidth,
                );
                var buttonPromptObj = {
                    title: thisTemp.ckLanguage["volumeSliderOver"].replace(
                        "[$volume]",
                        eventVolume,
                    ),
                    x: eventX,
                    y: volumeBgXY["y"],
                };
                thisTemp.promptShow(false, buttonPromptObj);
            };
            this.addListenerInside("mousemove", volumeBgMove, this.CB["volumeBg"]);
            this.addListenerInside("mouseout", promptHide, this.CB["volumeBg"]);
            this.addListenerInside("mouseout", promptHide, this.CB["volumeBO"]);
            //注册清晰度相关事件
            this.addDefListener();
            //注册倍速相关事件
            this.addPlaybackrate();
            //注册多字幕事件
            this.addSubtitles();
        },
        /*
			内部函数
			注册单击视频动作
		*/
        videoClick: function () {
            var thisTemp = this;
            var clearTimerClick = function () {
                if (thisTemp.timerClick != null) {
                    if (thisTemp.timerClick.runing) {
                        thisTemp.timerClick.stop();
                    }
                    thisTemp.timerClick = null;
                }
            };
            var timerClickFun = function () {
                clearTimerClick();
                thisTemp.isClick = false;
                thisTemp.sendJS("videoClick", thisTemp.videoClickXy);
                if (thisTemp.adPlayerPlay) {
                    var ad = thisTemp.getNowAdvertisements();
                    try {
                        if (ad["link"] != "") {
                            window.open(ad["link"]);
                        }
                        thisTemp.ajaxSuccessNull(ad["clickMonitor"]);
                    } catch (event) {
                    }
                } else {
                    if (thisTemp.ckConfig["config"]["click"]) {
                        thisTemp.playOrPause();
                    }
                }
            };
            clearTimerClick();
            if (this.isClick) {
                this.isClick = false;
                thisTemp.sendJS("videoDoubleClick", thisTemp.videoClickXy);
                if (thisTemp.ckConfig["config"]["doubleClick"]) {
                    if (!this.full) {
                        thisTemp.fullScreen();
                    } else {
                        thisTemp.quitFullScreen();
                    }
                }
            } else {
                this.isClick = true;
                this.timerClick = new this.timer(300, timerClickFun, 1);
                //this.timerClick.start();
            }
        },
        /*
			内部函数
			注册鼠标经过进度滑块的事件
		*/
        timeButtonMouseDown: function () {
            var thisTemp = this;
            var timePrompt = function (time) {
                if (isNaN(time)) {
                    time = 0;
                }
                var timeButtonXY = thisTemp.getCoor(thisTemp.CB["timeButton"]);
                var promptObj = {
                    title: thisTemp.formatTime(
                        time,
                        0,
                        thisTemp.ckLanguage["timeSliderOver"],
                    ),
                    x:
                        timeButtonXY["x"] -
                        thisTemp.pdCoor["x"] +
                        thisTemp.CB["timeButton"].offsetWidth * 0.5,
                    y: timeButtonXY["y"] - thisTemp.pdCoor["y"],
                };
                thisTemp.promptShow(false, promptObj);
            };
            var timeObj = {
                slider: this.CB["timeButton"],
                follow: this.CB["timeProgress"],
                refer: this.CB["timeBoBg"],
                grossValue: "time",
                pd: false,
                startFun: function (time) {
                    thisTemp.isTimeButtonMove = false;
                },
                monitorFun: function (time) {
                },
                endFun: function (time) {
                    if (thisTemp.V) {
                        if (thisTemp.V.duration > 0) {
                            thisTemp.needSeek = 0;
                            thisTemp.videoSeek(parseInt(time));
                        }
                    }
                },
                overFun: function (time) {
                    timePrompt(time);
                },
            };
            var timeClickObj = {
                refer: this.CB["timeBoBg"],
                grossValue: "time",
                fun: function (time) {
                    if (thisTemp.V) {
                        if (thisTemp.V.duration > 0) {
                            thisTemp.needSeek = 0;
                            thisTemp.videoSeek(parseInt(time));
                        }
                    }
                },
            };
            var timeBoBgmousemove = function (event) {
                var timeBoBgXY = thisTemp.getCoor(thisTemp.CB["timeBoBg"]);
                var eventX = thisTemp.client(event)["x"];
                var duration = thisTemp.V.duration;
                if (isNaN(duration) || parseInt(duration) < 0.2) {
                    duration = thisTemp.vars["duration"];
                }
                if (thisTemp.vars["forceduration"] > 0) {
                    duration = thisTemp.vars["forceduration"];
                }
                var eventTime = parseInt(
                    ((eventX - timeBoBgXY["x"]) * duration) /
                    thisTemp.CB["timeBoBg"].offsetWidth,
                );
                var buttonPromptObj = {
                    title: thisTemp.formatTime(
                        eventTime,
                        0,
                        thisTemp.ckLanguage["timeSliderOver"],
                    ),
                    x: eventX,
                    y: timeBoBgXY["y"],
                };
                thisTemp.promptShow(false, buttonPromptObj);
                var def = false;
                if (!thisTemp.isUndefined(thisTemp.CB["definitionP"])) {
                    if (thisTemp.css(thisTemp.CB["definitionP"], "display") != "block") {
                        def = true;
                    }
                }
                if (thisTemp.vars["preview"] != null && def) {
                    buttonPromptObj["time"] = eventTime;
                    thisTemp.preview(buttonPromptObj);
                }
            };
            var promptHide = function (event) {
                thisTemp.promptShow(false);
                if (thisTemp.previewDiv != null) {
                    thisTemp.css(
                        [thisTemp.previewDiv, thisTemp.previewTop],
                        "display",
                        "none",
                    );
                }
            };
            if (!this.vars["live"]) {
                //如果不是直播
                this.isTimeButtonDown = true;
                this.addListenerInside(
                    "mousemove",
                    timeBoBgmousemove,
                    this.CB["timeBoBg"],
                );
                this.addListenerInside("mouseout", promptHide, this.CB["timeBoBg"]);
            } else {
                this.isTimeButtonDown = false;
                timeObj["removeListenerInside"] = true;
                timeClickObj["removeListenerInside"] = true;
            }
            this.slider(timeObj);
            this.progressClick(timeClickObj);
        },
        /*
			内部函数
			注册调节框上单击事件，包含音量调节框和播放时度调节框
		*/
        progressClick: function (obj) {
            /*
				refer:参考对象
				fun:返回函数
				refer:参考元素，即背景
				grossValue:调用的参考值类型
				pd:
			*/
            //建立参考元素的mouseClick事件，用来做为鼠标在其上按下时触发的状态
            var thisTemp = this;
            var referMouseClick = function (event) {
                var referX =
                    thisTemp.client(event)["x"] - thisTemp.getCoor(obj["refer"])["x"];
                var rWidth = obj["refer"].offsetWidth;
                var grossValue = 0;
                if (obj["grossValue"] == "volume") {
                    grossValue = 100;
                } else {
                    if (thisTemp.V) {
                        grossValue = thisTemp.V.duration;
                        if (isNaN(grossValue) || parseInt(grossValue) < 0.2) {
                            grossValue = thisTemp.vars["duration"];
                        }
                        if (thisTemp.vars["forceduration"] > 0) {
                            grossValue = thisTemp.vars["forceduration"];
                        }
                    }
                }
                var nowZ = parseInt((referX * grossValue) / rWidth);
                if (obj["fun"]) {
                    if (obj["grossValue"] === "time") {
                        var sliderXY = thisTemp.getCoor(thisTemp.CB["timeButton"]);
                        sliderLeft = sliderXY["x"];
                        if (!thisTemp.checkSlideLeft(referX, sliderLeft, rWidth)) {
                            return;
                        }
                        var bimeButtonWB = thisTemp.CB["timeButton"].offsetWidth * 0.5;
                        thisTemp.css(
                            thisTemp.CB["timeButton"],
                            "left",
                            referX - bimeButtonWB + "px",
                        );
                        thisTemp.css(thisTemp.CB["timeProgress"], "width", referX + "px");
                    }
                    obj["fun"](nowZ);
                }
            };
            if (this.isUndefined(obj["removeListenerInside"])) {
                this.addListenerInside("click", referMouseClick, obj["refer"]);
            } else {
                this.removeListenerInside("click", referMouseClick, obj["refer"]);
            }
        },

        /*
			内部函数
			共用的注册滑块事件
		*/
        slider: function (obj) {
            /*
				obj={
					slider:滑块元素
					follow:跟随滑块的元素
					refer:参考元素，即背景
					grossValue:调用的参考值类型
					startFun:开始调用的元素
					monitorFun:监听函数
					endFun:结束调用的函数
					overFun:鼠标放上去后调用的函数
					pd:是否需要修正
				}
			*/
            var thisTemp = this;
            var clientX = 0,
                criterionWidth = 0,
                sliderLeft = 0,
                referLeft = 0;
            var value = 0;
            var calculation = function () {
                //根据滑块的left计算百分比
                var sLeft = parseInt(thisTemp.css(obj["slider"], "left"));
                var rWidth = obj["refer"].offsetWidth - obj["slider"].offsetWidth;
                var grossValue = 0;
                if (thisTemp.isUndefined(sLeft) || isNaN(sLeft)) {
                    sLeft = 0;
                }
                if (obj["grossValue"] == "volume") {
                    grossValue = 100;
                } else {
                    if (thisTemp.V) {
                        grossValue = thisTemp.V.duration;
                    }
                }
                return parseInt((sLeft * grossValue) / rWidth);
            };
            var mDown = function (event) {
                thisTemp.addListenerInside("mousemove", mMove, document);
                thisTemp.addListenerInside("mouseup", mUp, document);
                var referXY = thisTemp.getCoor(obj["refer"]);
                var sliderXY = thisTemp.getCoor(obj["slider"]);
                clientX = thisTemp.client(event)["x"];
                referLeft = referXY["x"];
                sliderLeft = sliderXY["x"];
                criterionWidth = clientX - sliderLeft;
                if (obj["startFun"]) {
                    obj["startFun"](calculation());
                }
            };
            var mMove = function (event) {
                clientX = thisTemp.client(event)["x"];
                var newX = clientX - criterionWidth - referLeft;
                if (newX < 0) {
                    newX = 0;
                }
                if (newX > obj["refer"].offsetWidth - obj["slider"].offsetWidth) {
                    newX = obj["refer"].offsetWidth - obj["slider"].offsetWidth;
                }
                if (obj["slider"] === thisTemp.CB["timeButton"]) {
                    if (
                        !thisTemp.checkSlideLeft(newX, sliderLeft, obj["refer"].offsetWidth)
                    ) {
                        return;
                    }
                }
                thisTemp.css(obj["slider"], "left", newX + "px");
                thisTemp.css(
                    obj["follow"],
                    "width",
                    newX + obj["slider"].offsetWidth * 0.5 + "px",
                );
                var nowZ = calculation();
                if (obj["monitorFun"]) {
                    obj["monitorFun"](nowZ);
                }
            };
            var mUp = function (event) {
                thisTemp.removeListenerInside("mousemove", mMove, document);
                thisTemp.removeListenerInside("mouseup", mUp, document);
                if (obj["endFun"]) {
                    obj["endFun"](calculation());
                }
            };
            var mOver = function (event) {
                if (obj["overFun"]) {
                    obj["overFun"](calculation());
                }
            };
            if (this.isUndefined(obj["removeListenerInside"])) {
                this.addListenerInside("mousedown", mDown, obj["slider"]);
                this.addListenerInside("mouseover", mOver, obj["slider"]);
            } else {
                this.removeListenerInside("mousedown", mDown, obj["slider"]);
                this.removeListenerInside("mouseover", mOver, obj["slider"]);
            }
        },
        /*
			内部函数
			判断是否可以拖动进度按钮或点击进度栏
		*/
        checkSlideLeft: function (newX, sliderLeft, refer) {
            var timeSA = this.ckConfig["config"]["timeScheduleAdjust"];
            switch (timeSA) {
                case 0:
                    return false;
                    break;
                case 2:
                    if (newX < sliderLeft) {
                        return false;
                    }
                    break;
                case 3:
                    if (newX > sliderLeft) {
                        return false;
                    }
                    break;
                case 4:
                    if (!this.timeSliderLeftTemp) {
                        this.timeSliderLeftTemp = sliderLeft / refer;
                    }
                    if (newX < this.timeSliderLeftTemp * refer) {
                        return false;
                    }
                    break;
                case 5:
                    if (!this.timeSliderLeftTemp) {
                        this.timeSliderLeftTemp = sliderLeft / refer;
                    } else {
                        var timeSliderMax = sliderLeft / refer;
                        if (timeSliderMax > this.timeSliderLeftTemp) {
                            this.timeSliderLeftTemp = timeSliderMax;
                        }
                    }
                    if (newX > this.timeSliderLeftTemp * refer) {
                        return false;
                    }
                    break;
                default:
                    return true;
                    break;
            }
            return true;
        },
        /*
			内部函数
			显示loading
		*/
        loadingStart: function (rot) {
            var thisTemp = this;
            if (this.isUndefined(rot)) {
                rot = true;
            }
            if (this.conBarShow) {
                this.css(thisTemp.CB["loading"], "display", "none");
                this.loadingShow = false;
            }
            var buffer = 0;
            if (rot) {
                if (this.conBarShow) {
                    this.css(thisTemp.CB["loading"], "display", "block");
                    this.loadingShow = true;
                }
            } else {
                thisTemp.sendJS("buffer", 100);
            }
        },
        /*
			内部函数
			显示提示语
		*/
        promptShow: function (ele, data) {
            if (!this.conBarShow) {
                return;
            }
            var obj = {};
            var eleTitle = "";
            if (!this.isUndefined(ele)) {
                eleTitle = this.getDataset(ele, "title");
                if (this.isUndefined(eleTitle)) {
                    ele = null;
                }
            }
            if (ele || data) {
                if (!this.isUndefined(data)) {
                    obj = data;
                } else {
                    var offsetCoor = this.getCoor(ele);
                    obj = {
                        title: eleTitle,
                        x: offsetCoor["x"] + ele.offsetWidth * 0.5,
                        y: offsetCoor["y"],
                    };
                }
                this.CB["prompt"].innerHTML = obj["title"];
                this.css(this.CB["prompt"], "display", "block");
                var promptStye = this.ckStyle["prompt"];
                var promoptWidth = this.CB["prompt"].offsetWidth,
                    promoptHeight = this.CB["prompt"].offsetHeight;
                this.css(this.CB["promptBg"], {
                    width: promoptWidth + "px",
                    height: promoptHeight + "px",
                });
                var x = obj["x"] - promoptWidth * 0.5;
                var y =
                    obj["y"] -
                    this.CB["prompt"].offsetHeight -
                    promptStye["marginBottom"] -
                    promptStye["triangleHeight"];
                if (x < 0) {
                    x = 0;
                }
                if (x > this.PD.offsetWidth - promoptWidth) {
                    x = this.PD.offsetWidth - promoptWidth;
                }
                this.css([this.CB["promptBg"], this.CB["prompt"]], {
                    display: "block",
                    left: x + "px",
                    top: y + "px",
                });
                this.css(this.CB["promptTriangle"], {
                    display: "block",
                    left:
                        x +
                        (promoptWidth - promptStye["triangleWidth"]) * 0.5 +
                        parseInt(promptStye["triangleDeviationX"]) +
                        "px",
                    top: y + promoptHeight + "px",
                });
            } else {
                this.css(
                    [this.CB["promptBg"], this.CB["prompt"], this.CB["promptTriangle"]],
                    {
                        display: "none",
                    },
                );
            }
        },
        /*
			内部函数
			监听错误
		*/
        timerErrorFun: function () {
            var thisTemp = this;
            this.errorSend = false;
            var clearIntervalError = function (event) {
                if (thisTemp.timerError != null) {
                    if (thisTemp.timerError.runing) {
                        thisTemp.timerError.stop();
                    }
                    thisTemp.timerError = null;
                }
            };
            var errorFun = function (event) {
                clearIntervalError();
                thisTemp.error = true;
                //提取错误播放地址
                thisTemp.errorUrl = thisTemp.getVideoUrl();
                //提取错误播放地址结束
                if (!thisTemp.errorSend) {
                    thisTemp.errorSend = true;
                    thisTemp.sendJS("error");
                }
                if (thisTemp.conBarShow) {
                    thisTemp.CB["errorText"].innerHTML =
                        thisTemp.ckLanguage["error"]["streamNotFound"];
                    thisTemp.css(thisTemp.CB["errorText"], "display", "block");
                    thisTemp.css(
                        [thisTemp.CB["pauseCenter"], thisTemp.CB["loading"]],
                        "display",
                        "none",
                    );
                }
                thisTemp.V.removeAttribute("poster");
                thisTemp.resetPlayer();
            };
            var errorListenerFun = function (event) {
                setTimeout(function () {
                    if (isNaN(thisTemp.V.duration)) {
                        errorFun(event);
                    }
                }, 500);
            };
            if (!this.errorAdd) {
                this.errorAdd = true;
                this.addListenerInside("error", errorListenerFun);
            }
            clearIntervalError();
            var timerErrorFun = function () {
                if (thisTemp.V && parseInt(thisTemp.V.networkState) == 3) {
                    errorFun();
                }
            };
            this.timerError = new this.timer(
                this.ckConfig["config"]["errorTime"],
                timerErrorFun,
            );
        },
        /*
			内部函数
			构建判断全屏还是非全屏的判断
		*/
        judgeFullScreen: function () {
            var thisTemp = this;
            if (this.timerFull != null) {
                if (this.timerFull.runing) {
                    this.timerFull.stop();
                }
                this.timerFull = null;
            }
            var fullFun = function () {
                thisTemp.isFullScreen();
            };
            this.timerFull = new this.timer(20, fullFun);
        },
        /*
			内部函数
			判断是否是全屏
		*/
        isFullScreen: function () {
            if (!this.conBarShow) {
                return;
            }
            var fullState =
                document.fullScreen ||
                document.mozFullScreen ||
                document.webkitIsFullScreen ||
                document.msFullscreenElement;
            if (fullState && !this.full) {
                this.full = true;
                this.sendJS("full", true);
                this.elementCoordinate();
                this.carbarButton();
                this.customCoor(); //控制栏自定义元件
                this.css(this.CB["full"], "display", "none");
                this.css(this.CB["escFull"], "display", "block");
                if (this.vars["live"] == 0) {
                    this.timeUpdateHandler();
                }
                this.PD.appendChild(this.CB["menu"]);
            }
            if (!fullState && this.full) {
                this.full = false;
                this.sendJS("full", false);
                this.elementCoordinate();
                this.carbarButton();
                this.customCoor(); //控制栏自定义元件
                this.css(this.CB["full"], "display", "block");
                this.css(this.CB["escFull"], "display", "none");
                if (this.timerFull != null) {
                    if (this.timerFull.runing) {
                        this.timerFull.stop();
                    }
                    this.timerFull = null;
                }
                if (this.vars["live"] == 0) {
                    this.timeUpdateHandler();
                }
                this.body.appendChild(this.CB["menu"]);
            }
        },
        /*
			内部函数
			构建右键内容及注册相关动作事件
		*/
        newMenu: function () {
            var thisTemp = this;
            var i = 0;
            this.css(this.CB["menu"], {
                backgroundColor: "#FFFFFF",
                padding: "5px",
                position: "absolute",
                left: "10px",
                top: "20px",
                display: "none",
                zIndex: "999",
                color: "#A1A9BE",
                boxShadow: "2px 2px 3px #AAAAAA",
            });
            var mArr = this.contextMenu;
            var cMenu = this.ckConfig["menu"];
            if (cMenu["name"]) {
                if (cMenu["link"]) {
                    mArr[0] = [cMenu["name"], "link", cMenu["link"]];
                } else {
                    mArr[0] = [cMenu["name"], "default"];
                }
            }
            if (cMenu["version"]) {
                mArr[1] = [cMenu["version"], "default", "line"];
            }
            if (cMenu["more"]) {
                if (this.varType(cMenu["more"]) == "array") {
                    if (cMenu["more"].length > 0) {
                        var moreArr = cMenu["more"];
                        for (i = 0; i < moreArr.length; i++) {
                            var mTemp = moreArr[i];
                            var arrTemp = [];
                            if (mTemp["name"]) {
                                arrTemp.push(mTemp["name"]);
                            }
                            if (mTemp["clickEvent"] && mTemp["clickEvent"] != "none") {
                                var eveObj = this.clickEvent(mTemp["clickEvent"]);
                                arrTemp.push(eveObj["type"]);
                                if (eveObj["fun"]) {
                                    arrTemp.push(eveObj["fun"]);
                                }
                                if (eveObj["link"]) {
                                    arrTemp.push(eveObj["link"]);
                                }
                                if (eveObj["target"]) {
                                    arrTemp.push(' target="' + eveObj["target"] + '"');
                                }
                            }
                            if (mTemp["separatorBefore"]) {
                                arrTemp.push("line");
                            }
                            mArr.push(arrTemp);
                        }
                    }
                }
            }
            var html = "";
            for (i = 0; i < mArr.length; i++) {
                var me = mArr[i];
                switch (me[1]) {
                    case "default":
                        html += "<p>" + me[0] + "</p>";
                        break;
                    case "link":
                        if (me[3]) {
                            me[3] = 'target="' + me[3] + '"';
                        }
                        html +=
                            '<p><a href="' + me[2] + '"' + me[3] + ">" + me[0] + "</a></p>";
                        break;
                    case "javaScript":
                        html +=
                            '<p><a href="javascript:' + me[2] + '">' + me[0] + "</a></p>";
                        break;
                    case "actionScript":
                        html +=
                            '<p><a href="javascript:' +
                            this.vars["variable"] +
                            me[2].replace("thisTemp", "") +
                            '">' +
                            me[0] +
                            "</a></p>";
                        break;
                    default:
                        break;
                }
            }
            this.CB["menu"].innerHTML = html;
            var pArr = this.CB["menu"].childNodes;
            for (i = 0; i < pArr.length; i++) {
                this.css(pArr[i], {
                    height: "30px",
                    lineHeight: "30px",
                    margin: "0px",
                    fontFamily: this.fontFamily,
                    fontSize: "12px",
                    paddingLeft: "10px",
                    paddingRight: "30px",
                });
                if (mArr[i][mArr[i].length - 1] == "line") {
                    this.css(pArr[i], "borderBottom", "1px solid #e9e9e9");
                }
                var aArr = pArr[i].childNodes;
                for (var n = 0; n < aArr.length; n++) {
                    if (aArr[n].localName == "a") {
                        this.css(aArr[n], {
                            color: "#000000",
                            textDecoration: "none",
                        });
                    }
                }
            }
            this.PD.oncontextmenu = function (event) {
                var eve = event || window.event;
                var client = thisTemp.client(event);
                if (eve.button == 2) {
                    eve.returnvalue = false;
                    var x = client["x"] + thisTemp.pdCoor["x"] - 2;
                    var y = client["y"] + thisTemp.pdCoor["y"] - 2;
                    thisTemp.css(thisTemp.CB["menu"], {
                        display: "block",
                        left: x + "px",
                        top: y + "px",
                    });
                    return false;
                }
                return true;
            };
            var setTimeOutPClose = function () {
                if (setTimeOutP) {
                    window.clearTimeout(setTimeOutP);
                    setTimeOutP = null;
                }
            };
            var setTimeOutP = null;
            var mouseOut = function (event) {
                setTimeOutPClose();
                setTimeOutP = setTimeout(function (event) {
                    thisTemp.css(thisTemp.CB["menu"], "display", "none");
                }, 500);
            };
            this.addListenerInside("mouseout", mouseOut, thisTemp.CB["menu"]);
            var mouseOver = function (event) {
                setTimeOutPClose();
            };
            this.addListenerInside("mouseover", mouseOver, thisTemp.CB["menu"]);
        },
        /*
			内部函数
			构建控制栏隐藏事件
		*/
        controlBarHide: function (hide) {
            var thisTemp = this;
            var client = {
                    x: 0,
                    y: 0,
                },
                oldClient = {
                    x: 0,
                    y: 0,
                };
            var cShow = true,
                force = false;
            var oldCoor = [0, 0];
            var controlBarShow = function (show) {
                if (show && !cShow && thisTemp.controlBarIsShow) {
                    cShow = true;
                    thisTemp.sendJS("controlBar", true);
                    thisTemp.css(thisTemp.CB["controlBarBg"], "display", "block");
                    thisTemp.css(thisTemp.CB["controlBar"], "display", "block");
                    thisTemp.timeProgressDefault();
                    //thisTemp.css(thisTemp.CB['timeProgressBg'], 'display', 'block');
                    //thisTemp.css(thisTemp.CB['timeBoBg'], 'display', 'block');
                    thisTemp.changeVolume(thisTemp.volume);
                    thisTemp.changeLoad();
                    if (!thisTemp.timerBuffer) {
                        thisTemp.bufferEdHandler();
                    }
                } else {
                    if (cShow) {
                        cShow = false;
                        var paused = thisTemp.getMetaDate()["paused"];
                        if (force) {
                            paused = false;
                        }
                        if (!paused) {
                            thisTemp.sendJS("controlBar", false);
                            thisTemp.css(thisTemp.CB["controlBarBg"], "display", "none");
                            thisTemp.css(thisTemp.CB["controlBar"], "display", "none");
                            thisTemp.promptShow(false);
                        }
                    }
                }
                thisTemp.videoCss(); //计算video的宽高和位置
            };
            var cbarFun = function (event) {
                if (client["x"] == oldClient["x"] && client["y"] == oldClient["y"]) {
                    var cdH = parseInt(thisTemp.CD.offsetHeight);
                    if (
                        (client["y"] < cdH - 50 || client["y"] > cdH - 2) &&
                        cShow &&
                        !thisTemp.getMetaDate()["paused"]
                    ) {
                        controlBarShow(false);
                    }
                } else {
                    if (!cShow) {
                        controlBarShow(true);
                    }
                }
                oldClient = {
                    x: client["x"],
                    y: client["y"],
                };
            };
            this.timerCBar = new this.timer(2000, cbarFun);
            var cdMove = function (event) {
                var getClient = thisTemp.client(event);
                client["x"] = getClient["x"];
                client["y"] = getClient["y"];
                if (!cShow) {
                    controlBarShow(true);
                }
                thisTemp.sendJS("mouse", client);
            };
            this.addListenerInside("mousemove", cdMove, thisTemp.CD);
            this.addListenerInside("ended", cdMove);
            this.addListenerInside("resize", cdMove, window);
            if (hide === true) {
                cShow = true;
                force = true;
                controlBarShow(false);
            }
            if (hide === false) {
                cShow = false;
                force = true;
                controlBarShow(true);
            }
        },

        /*
			内部函数
			注册键盘按键事件
		*/
        keypress: function () {
            var thisTemp = this;
            var keyDown = function (eve) {
                var keycode = eve.keyCode || eve.which;
                if (thisTemp.adPlayerPlay) {
                    return;
                }
                switch (keycode) {
                    case 32:
                        thisTemp.playOrPause();
                        break;
                    case 37:
                        thisTemp.fastBack();
                        break;
                    case 39:
                        thisTemp.fastNext();
                        break;
                    case 38:
                        now = thisTemp.volume + thisTemp.ckConfig["config"]["volumeJump"];
                        thisTemp.changeVolume(now > 1 ? 1 : now);
                        break;
                    case 40:
                        now = thisTemp.volume - thisTemp.ckConfig["config"]["volumeJump"];
                        thisTemp.changeVolume(now < 0 ? 0 : now);
                        break;
                    default:
                        break;
                }
            };
            this.addListenerInside("keydown", keyDown, window || document);
        },
        /*
			内部函数
			注册倍速相关
		*/
        playbackRate: function () {
            if (!this.conBarShow || !this.ckConfig["config"]["playbackRate"]) {
                return;
            }
            var styleCD = this.ckStyle["controlBar"]["playbackrate"];
            var cssSup = {overflow: "hidden", display: "none", zIndex: 995};
            var cssSup2 = {
                overflow: "hidden",
                align: "top",
                vAlign: "left",
                offsetX: 0,
                offsetY: 0,
                zIndex: 1,
            };
            var thisTemp = this;
            var dArr = this.playbackRateArr;
            var html = "";
            var nowD = ""; //当前的倍速
            var i = 0,
                nowI = 0;
            nowD = dArr[this.playbackRateDefault][1];
            nowI = this.playbackRateDefault;
            this.removeChildAll(this.CB["playbackrateP"]);
            if (dArr.length > 1) {
                //设置样式
                (this.CB["playbackratePB"] = document.createElement("div")),
                    (this.CB["playbackratePC"] = document.createElement("div"));
                this.CB["playbackrateP"].appendChild(this.CB["playbackratePB"]);
                this.CB["playbackrateP"].appendChild(this.CB["playbackratePC"]);
                //按钮列表容器样式
                var bgCss = this.newObj(styleCD["background"]);
                bgCss["backgroundColor"] = "";
                //内容层样式
                cssTemp = this.getEleCss(bgCss, cssSup2);
                this.css(this.CB["playbackratePC"], cssTemp);
                bgCss["padding"] = 0;
                bgCss["paddingLeft"] = 0;
                bgCss["paddingTop"] = 0;
                bgCss["paddingRight"] = 0;
                bgCss["paddingBottom"] = 0;
                //容器层样式
                cssTemp = this.getEleCss(
                    this.objectAssign(bgCss, styleCD["backgroundCoorH5"]),
                    cssSup,
                );
                this.css(this.CB["playbackrateP"], cssTemp);
                //背景层样式
                bgCss = this.newObj(styleCD["background"]);
                bgCss["alpha"] = bgCss["backgroundAlpha"];
                bgCss["padding"] = 0;
                bgCss["paddingLeft"] = 0;
                bgCss["paddingTop"] = 0;
                bgCss["paddingRight"] = 0;
                bgCss["paddingBottom"] = 0;
                cssTemp = this.getEleCss(bgCss, cssSup2);
                this.css(this.CB["playbackratePB"], cssTemp);
                //样式设置结束
                for (i = 0; i < dArr.length; i++) {
                    var buttonDiv = document.createElement("div");
                    buttonDiv.dataset.title = dArr[i][1];
                    if (nowI != i) {
                        this.textButton(
                            buttonDiv,
                            styleCD["button"],
                            null,
                            this.CB["playbackrateP"],
                            dArr[i][1],
                            "",
                        );
                    } else {
                        this.textButton(
                            buttonDiv,
                            styleCD["buttonHighlight"],
                            null,
                            this.CB["playbackrateP"],
                            dArr[i][1],
                            "",
                        );
                    }
                    this.css(buttonDiv, "position", "static");
                    this.CB["playbackratePC"].appendChild(buttonDiv);
                    //构建间隔线
                    if (i < dArr.length - 1) {
                        var separate = styleCD["separate"];
                        separate["borderTop"] = separate["border"];
                        separate["borderTopColor"] = separate["color"];
                        var separateDiv = document.createElement("div");
                        this.CB["playbackratePC"].appendChild(separateDiv);
                        var cssTemp = this.getEleCss(separate, {width: "100%"});
                        cssTemp["position"] = "static";
                        this.css(separateDiv, cssTemp);
                    }
                    var subClick = function () {
                        var dName = thisTemp.getDataset(this, "title");
                        if (nowD != dName) {
                            thisTemp.css(thisTemp.CB["playbackrateP"], "display", "none");
                            thisTemp.newPlaybackrate(dName);
                        }
                    };
                    this.addListenerInside("click", subClick, buttonDiv);
                }
                //下面三角形样式
                this.CB["playbackrateTriangle"] = document.createElement("div");
                this.CB["playbackrateP"].appendChild(this.CB["playbackrateTriangle"]);
                var tbCss = styleCD["background"];
                cssTemp = {
                    width: 0,
                    height: 0,
                    borderLeft: tbCss["triangleWidth"] * 0.5 + "px solid transparent",
                    borderRight: tbCss["triangleWidth"] * 0.5 + "px solid transparent",
                    borderTop:
                        tbCss["triangleHeight"] +
                        "px solid " +
                        tbCss["triangleBackgroundColor"].replace("0x", "#"),
                    overflow: "hidden",
                    opacity: tbCss["triangleAlpha"],
                    filter: "alpha(opacity:" + tbCss["triangleAlpha"] + ")",
                    position: "absolute",
                    left: "0px",
                    top: "0px",
                    zIndex: 2,
                };
                this.css(this.CB["playbackrateTriangle"], cssTemp);
                this.CB["playbackrateButtonText"].innerHTML = nowD;
            } else {
                this.CB["playbackrateButtonText"].innerHTML =
                    this.ckLanguage["playbackrate"];
            }
        },
        /*
			内部函数
			注册切换倍速播放相关事件
		*/
        addPlaybackrate: function () {
            var thisTemp = this;
            var setTimeOutP = null;
            var defClick = function (event) {
                if (
                    thisTemp.css(thisTemp.CB["playbackrateP"], "display") != "block" &&
                    !thisTemp.isUndefined(thisTemp.CB["playbackratePC"])
                ) {
                    thisTemp.css(thisTemp.CB["playbackrateP"], "display", "block");
                    var tbCss =
                        thisTemp.ckStyle["controlBar"]["playbackrate"]["background"];
                    thisTemp.css(thisTemp.CB["playbackratePB"], {
                        width: thisTemp.CB["playbackratePC"].offsetWidth + "px",
                        height: thisTemp.CB["playbackratePC"].offsetHeight + "px",
                    });
                    thisTemp.css(thisTemp.CB["playbackrateP"], {
                        width:
                            thisTemp.CB["playbackratePC"].offsetWidth +
                            tbCss["triangleDeviationX"] +
                            tbCss["triangleWidth"] +
                            "px",
                        height:
                            thisTemp.CB["playbackratePC"].offsetHeight +
                            tbCss["triangleDeviationY"] +
                            tbCss["triangleHeight"] +
                            "px",
                    });
                    thisTemp.promptShow(false);
                    //设置三角形样式
                    var tempELe = thisTemp.CB["playbackratePB"];
                    var tempWidth = tempELe.offsetWidth,
                        tempHeight = tempELe.offsetHeight;

                    var x =
                        (tempWidth - tbCss["triangleWidth"]) * 0.5 +
                        tbCss["triangleDeviationX"];
                    var y = tempELe.offsetHeight + tbCss["triangleDeviationY"];
                    var cssTemp = {
                        left: x + "px",
                        top: y + "px",
                    };
                    thisTemp.css(thisTemp.CB["playbackrateTriangle"], cssTemp);
                } else {
                    thisTemp.css(thisTemp.CB["playbackrateP"], "display", "none");
                }
            };
            this.addListenerInside("click", defClick, this.CB["playbackrate"]);
            var defMouseOut = function (event) {
                if (setTimeOutP) {
                    window.clearTimeout(setTimeOutP);
                    setTimeOutP = null;
                }
                setTimeOutP = setTimeout(function (event) {
                    thisTemp.css(thisTemp.CB["playbackrateP"], "display", "none");
                }, 500);
            };
            this.addListenerInside(
                "mouseout",
                defMouseOut,
                thisTemp.CB["playbackrateP"],
            );
            var defMouseOver = function (event) {
                if (setTimeOutP) {
                    thisTemp.buttonHide = false;
                    window.clearTimeout(setTimeOutP);
                    setTimeOutP = null;
                }
            };
            this.addListenerInside(
                "mouseover",
                defMouseOver,
                thisTemp.CB["playbackrateP"],
            );
        },
        /*
			内部函数
			切换倍速后发生的动作
		*/
        newPlaybackrate: function (title) {
            var vArr = this.playbackRateArr;
            var nVArr = [];
            var i = 0;
            for (i = 0; i < vArr.length; i++) {
                var v = vArr[i];
                if (v[1] == title) {
                    this.playbackRateDefault = i;
                    this.V.playbackRate = v[0];
                    if (this.conBarShow) {
                        this.CB["playbackrateButtonText"].innerHTML = v[1];
                        this.playbackRate();
                    }
                    this.sendJS("playbackRate", v);
                    this.playbackRateTemp = v[0];
                }
            }
        },
        /*
			内部函数
			注册多字幕切换相关
		*/
        subtitleSwitch: function () {
            if (!this.conBarShow || !this.ckConfig["config"]["subtitle"]) {
                return;
            }
            var thisTemp = this;
            var dArr = this.vars["cktrack"]; //字幕数组
            if (this.varType(dArr) != "array") {
                return;
            }
            if (dArr[0][1] == "") {
                return;
            }
            var styleCD = this.ckStyle["controlBar"]["subtitle"];
            var cssSup = {overflow: "hidden", display: "none", zIndex: 995};
            var cssSup2 = {
                overflow: "hidden",
                align: "top",
                vAlign: "left",
                offsetX: 0,
                offsetY: 0,
                zIndex: 1,
            };
            var html = "";
            var nowD = ""; //当前的字幕
            var i = 0,
                nowI = 0;

            if (this.subtitlesTemp == -1 && dArr.length > 0) {
                this.subtitlesTemp = dArr.length - 1;
            }
            for (i = 0; i < dArr.length; i++) {
                if (this.subtitlesTemp == i) {
                    nowD = dArr[i][1];
                    nowI = i;
                }
            }
            if (!nowD) {
                nowD = dArr[0][1];
            }
            this.removeChildAll(this.CB["subtitlesP"]);
            if (dArr.length > 1) {
                //设置样式
                (this.CB["subtitlesPB"] = document.createElement("div")),
                    (this.CB["subtitlesPC"] = document.createElement("div"));
                this.CB["subtitlesP"].appendChild(this.CB["subtitlesPB"]);
                this.CB["subtitlesP"].appendChild(this.CB["subtitlesPC"]);
                //按钮列表容器样式
                var bgCss = this.newObj(styleCD["background"]);
                bgCss["backgroundColor"] = "";
                //内容层样式
                cssTemp = this.getEleCss(bgCss, cssSup2);
                this.css(this.CB["subtitlesPC"], cssTemp);
                bgCss["padding"] = 0;
                bgCss["paddingLeft"] = 0;
                bgCss["paddingTop"] = 0;
                bgCss["paddingRight"] = 0;
                bgCss["paddingBottom"] = 0;
                //容器层样式
                cssTemp = this.getEleCss(
                    this.objectAssign(bgCss, styleCD["backgroundCoorH5"]),
                    cssSup,
                );
                this.css(this.CB["subtitlesP"], cssTemp);
                //背景层样式
                bgCss = this.newObj(styleCD["background"]);
                bgCss["alpha"] = bgCss["backgroundAlpha"];
                bgCss["padding"] = 0;
                bgCss["paddingLeft"] = 0;
                bgCss["paddingTop"] = 0;
                bgCss["paddingRight"] = 0;
                bgCss["paddingBottom"] = 0;
                cssTemp = this.getEleCss(bgCss, cssSup2);
                this.css(this.CB["subtitlesPB"], cssTemp);
                //样式设置结束
                for (i = 0; i < dArr.length; i++) {
                    var buttonDiv = document.createElement("div");
                    buttonDiv.dataset.title = dArr[i][1];
                    if (nowI != i) {
                        this.textButton(
                            buttonDiv,
                            styleCD["button"],
                            null,
                            this.CB["subtitlesP"],
                            dArr[i][1],
                            "",
                        );
                    } else {
                        this.textButton(
                            buttonDiv,
                            styleCD["buttonHighlight"],
                            null,
                            this.CB["subtitlesP"],
                            dArr[i][1],
                            "",
                        );
                    }
                    this.css(buttonDiv, "position", "static");
                    this.CB["subtitlesPC"].appendChild(buttonDiv);
                    //构建间隔线
                    if (i < dArr.length - 1) {
                        var separate = styleCD["separate"];
                        separate["borderTop"] = separate["border"];
                        separate["borderTopColor"] = separate["color"];
                        var separateDiv = document.createElement("div");
                        this.CB["subtitlesPC"].appendChild(separateDiv);
                        var cssTemp = this.getEleCss(separate, {width: "100%"});
                        cssTemp["position"] = "static";
                        this.css(separateDiv, cssTemp);
                    }
                    var subClick = function () {
                        var dName = thisTemp.getDataset(this, "title");
                        if (nowD != dName) {
                            thisTemp.css(thisTemp.CB["subtitlesP"], "display", "none");
                            thisTemp.newSubtitles(dName);
                        }
                    };
                    this.addListenerInside("click", subClick, buttonDiv);
                }
                //下面三角形样式
                this.CB["subtitlesTriangle"] = document.createElement("div");
                this.CB["subtitlesP"].appendChild(this.CB["subtitlesTriangle"]);
                var tbCss = styleCD["background"];
                cssTemp = {
                    width: 0,
                    height: 0,
                    borderLeft: tbCss["triangleWidth"] * 0.5 + "px solid transparent",
                    borderRight: tbCss["triangleWidth"] * 0.5 + "px solid transparent",
                    borderTop:
                        tbCss["triangleHeight"] +
                        "px solid " +
                        tbCss["triangleBackgroundColor"].replace("0x", "#"),
                    overflow: "hidden",
                    opacity: tbCss["triangleAlpha"],
                    filter: "alpha(opacity:" + tbCss["triangleAlpha"] + ")",
                    position: "absolute",
                    left: "0px",
                    top: "0px",
                    zIndex: 2,
                };
                this.css(this.CB["subtitlesTriangle"], cssTemp);
                this.CB["subtitleButtonText"].innerHTML = nowD;
            } else {
                this.CB["subtitleButtonText"].innerHTML = this.ckLanguage["subtitle"];
            }
        },
        /*
			内部函数
			注册多字幕切换事件
		*/
        addSubtitles: function () {
            var thisTemp = this;
            var setTimeOutP = null;
            var defClick = function (event) {
                if (
                    thisTemp.css(thisTemp.CB["subtitlesP"], "display") != "block" &&
                    !thisTemp.isUndefined(thisTemp.CB["subtitlesPC"])
                ) {
                    var tbCss = thisTemp.ckStyle["controlBar"]["subtitle"]["background"];
                    thisTemp.css(thisTemp.CB["subtitlesP"], "display", "block");
                    thisTemp.css(thisTemp.CB["subtitlesPB"], {
                        width: thisTemp.CB["subtitlesPC"].offsetWidth + "px",
                        height: thisTemp.CB["subtitlesPC"].offsetHeight + "px",
                    });
                    thisTemp.css(thisTemp.CB["subtitlesP"], {
                        width:
                            thisTemp.CB["subtitlesPC"].offsetWidth +
                            tbCss["triangleDeviationX"] +
                            tbCss["triangleWidth"] +
                            "px",
                        height:
                            thisTemp.CB["subtitlesPC"].offsetHeight +
                            tbCss["triangleDeviationY"] +
                            tbCss["triangleHeight"] +
                            "px",
                    });
                    thisTemp.promptShow(false);
                    //设置三角形样式
                    var tempELe = thisTemp.CB["subtitlesPB"];
                    var tempWidth = tempELe.offsetWidth,
                        tempHeight = tempELe.offsetHeight;

                    var x =
                        (tempWidth - tbCss["triangleWidth"]) * 0.5 +
                        tbCss["triangleDeviationX"];
                    var y = tempELe.offsetHeight + tbCss["triangleDeviationY"];
                    var cssTemp = {
                        left: x + "px",
                        top: y + "px",
                    };
                    thisTemp.css(thisTemp.CB["subtitlesTriangle"], cssTemp);
                } else {
                    thisTemp.css(thisTemp.CB["subtitlesP"], "display", "none");
                }
            };
            this.addListenerInside("click", defClick, this.CB["subtitles"]);
            var defMouseOut = function (event) {
                if (setTimeOutP) {
                    window.clearTimeout(setTimeOutP);
                    setTimeOutP = null;
                }
                setTimeOutP = setTimeout(function (event) {
                    thisTemp.css(thisTemp.CB["subtitlesP"], "display", "none");
                }, 500);
            };
            this.addListenerInside(
                "mouseout",
                defMouseOut,
                thisTemp.CB["subtitlesP"],
            );
            var defMouseOver = function (event) {
                thisTemp.buttonHide = false;
                if (setTimeOutP) {
                    window.clearTimeout(setTimeOutP);
                    setTimeOutP = null;
                }
            };
            this.addListenerInside(
                "mouseover",
                defMouseOver,
                thisTemp.CB["subtitlesP"],
            );
        },
        /*
			接口函数:修改字幕，按数组编号来
			提供给外部api
		*/
        changeSubtitles: function (n) {
            if (!this.loaded || n < 0) {
                return;
            }
            var vArr = this.vars["cktrack"]; //字幕数组
            if (this.varType(vArr) != "array") {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.changeSubtitles(n);
                return;
            }
            if (vArr.length > n) {
                var arr = vArr[n];
                if (arr.length > 2) {
                    var title = arr[1];
                    if (title) {
                        this.newSubtitles(title);
                    }
                }
            }
        },
        /*
			接口函数：修改字幕大小
			提供给外部api
		*/
        changeSubtitlesSize: function (n, m) {
            if (!this.loaded || n < 0) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.changeSubtitlesSize(n, m);
                return;
            }
            this.ckStyle["cktrack"]["size"] = n;
            if (!this.isUndefined(m)) {
                this.ckStyle["cktrack"]["leading"] = m;
            }
            this.trackShowAgain();
        },
        /*
			当切换字幕时的动作
		*/
        newSubtitles: function (title) {
            var vArr = this.vars["cktrack"]; //字幕数组
            var i = 0;
            for (i = 0; i < vArr.length; i++) {
                var v = vArr[i];
                if (v[1] == title) {
                    this.subtitlesTemp = i;
                    if (this.conBarShow) {
                        this.CB["subtitleButtonText"].innerHTML = v[1];
                        this.subtitleSwitch();
                        this.loadTrack(i);
                    }
                    this.sendJS("subtitles", v);
                }
            }
        },
        /*
			内部函数
			构建清晰度按钮及切换事件(Click事件)
		*/
        definition: function () {
            if (!this.conBarShow || !this.ckConfig["config"]["definition"]) {
                return;
            }
            var styleCD = this.ckStyle["controlBar"]["definition"];
            var cssSup = {overflow: "hidden", display: "none", zIndex: 995};
            var cssSup2 = {
                overflow: "hidden",
                align: "top",
                vAlign: "left",
                offsetX: 0,
                offsetY: 0,
                zIndex: 1,
            };
            var thisTemp = this;
            var vArr = this.VA;
            var dArr = [];
            var html = "";
            var nowD = ""; //当前的清晰度
            var i = 0,
                nowI = 0;
            for (i = 0; i < vArr.length; i++) {
                var d = vArr[i][2];
                if (dArr.indexOf(d) == -1) {
                    dArr.push(d);
                }
                if (this.V) {
                    if (vArr[i][0] == this.V.currentSrc) {
                        nowD = d;
                        nowI = i;
                    }
                }
            }
            if (!nowD) {
                nowD = dArr[0];
            }
            this.removeChildAll(this.CB["definitionP"]);
            if (dArr.length > 1) {
                //设置样式
                (this.CB["definitionPB"] = document.createElement("div")),
                    (this.CB["definitionPC"] = document.createElement("div"));
                this.CB["definitionP"].appendChild(this.CB["definitionPB"]);
                this.CB["definitionP"].appendChild(this.CB["definitionPC"]);
                //按钮列表容器样式
                var bgCss = this.newObj(styleCD["background"]);
                bgCss["backgroundColor"] = "";
                //内容层样式
                cssTemp = this.getEleCss(bgCss, cssSup2);
                this.css(this.CB["definitionPC"], cssTemp);
                bgCss["padding"] = 0;
                bgCss["paddingLeft"] = 0;
                bgCss["paddingTop"] = 0;
                bgCss["paddingRight"] = 0;
                bgCss["paddingBottom"] = 0;
                //容器层样式
                cssTemp = this.getEleCss(
                    this.objectAssign(bgCss, styleCD["backgroundCoorH5"]),
                    cssSup,
                );
                this.css(this.CB["definitionP"], cssTemp);
                //背景层样式
                bgCss = this.newObj(styleCD["background"]);
                bgCss["alpha"] = bgCss["backgroundAlpha"];
                bgCss["padding"] = 0;
                bgCss["paddingLeft"] = 0;
                bgCss["paddingTop"] = 0;
                bgCss["paddingRight"] = 0;
                bgCss["paddingBottom"] = 0;
                cssTemp = this.getEleCss(bgCss, cssSup2);
                this.css(this.CB["definitionPB"], cssTemp);
                //样式设置结束
                for (i = 0; i < dArr.length; i++) {
                    var buttonDiv = document.createElement("div");
                    buttonDiv.dataset.title = dArr[i];
                    if (nowI != i) {
                        this.textButton(
                            buttonDiv,
                            styleCD["button"],
                            null,
                            this.CB["definitionP"],
                            dArr[i],
                            "",
                        );
                    } else {
                        this.textButton(
                            buttonDiv,
                            styleCD["buttonHighlight"],
                            null,
                            this.CB["definitionP"],
                            dArr[i],
                            "",
                        );
                    }
                    this.css(buttonDiv, "position", "static");
                    this.CB["definitionPC"].appendChild(buttonDiv);
                    //构建间隔线
                    if (i < dArr.length - 1) {
                        var separate = styleCD["separate"];
                        separate["borderTop"] = separate["border"];
                        separate["borderTopColor"] = separate["color"];
                        var separateDiv = document.createElement("div");
                        this.CB["definitionPC"].appendChild(separateDiv);
                        var cssTemp = this.getEleCss(separate, {width: "100%"});
                        cssTemp["position"] = "static";
                        this.css(separateDiv, cssTemp);
                    }
                    var defClick = function () {
                        var dName = thisTemp.getDataset(this, "title");
                        if (nowD != dName) {
                            thisTemp.css(thisTemp.CB["definitionP"], "display", "none");
                            thisTemp.newDefinition(dName);
                        }
                    };
                    this.addListenerInside("click", defClick, buttonDiv);
                }
                //下面三角形样式
                this.CB["definitionTriangle"] = document.createElement("div");
                this.CB["definitionP"].appendChild(this.CB["definitionTriangle"]);
                var tbCss = styleCD["background"];
                cssTemp = {
                    width: 0,
                    height: 0,
                    borderLeft: tbCss["triangleWidth"] * 0.5 + "px solid transparent",
                    borderRight: tbCss["triangleWidth"] * 0.5 + "px solid transparent",
                    borderTop:
                        tbCss["triangleHeight"] +
                        "px solid " +
                        tbCss["triangleBackgroundColor"].replace("0x", "#"),
                    overflow: "hidden",
                    opacity: tbCss["triangleAlpha"],
                    filter: "alpha(opacity:" + tbCss["triangleAlpha"] + ")",
                    position: "absolute",
                    left: "0px",
                    top: "0px",
                    zIndex: 2,
                };
                this.css(this.CB["definitionTriangle"], cssTemp);
                this.CB["defaultButtonText"].innerHTML = nowD;
                this.css(this.CB["definition"], "display", "block");
            } else {
                this.CB["defaultButtonText"].innerHTML = this.ckLanguage["definition"];
            }
        },
        /*
			内部函数
			删除节点内容
		*/
        removeChildAll: function (ele) {
            for (var i = ele.childNodes.length - 1; i >= 0; i--) {
                var childNode = ele.childNodes[i];
                ele.removeChild(childNode);
            }
        },
        /*
			内部函数
			注册清晰度相关事件
		*/
        addDefListener: function () {
            var thisTemp = this;
            var setTimeOutP = null;
            var defClick = function (event) {
                if (
                    thisTemp.css(thisTemp.CB["definitionP"], "display") != "block" &&
                    !thisTemp.isUndefined(thisTemp.CB["definitionPC"])
                ) {
                    thisTemp.css(thisTemp.CB["definitionP"], "display", "block");
                    var tbCss =
                        thisTemp.ckStyle["controlBar"]["definition"]["background"];
                    thisTemp.css(thisTemp.CB["definitionPB"], {
                        width: thisTemp.CB["definitionPC"].offsetWidth + "px",
                        height: thisTemp.CB["definitionPC"].offsetHeight + "px",
                    });
                    thisTemp.css(thisTemp.CB["definitionP"], {
                        width:
                            thisTemp.CB["definitionPC"].offsetWidth +
                            tbCss["triangleDeviationX"] +
                            tbCss["triangleWidth"] +
                            "px",
                        height:
                            thisTemp.CB["definitionPC"].offsetHeight +
                            tbCss["triangleDeviationY"] +
                            tbCss["triangleHeight"] +
                            "px",
                    });
                    thisTemp.promptShow(false);
                    //设置三角形样式
                    var tempELe = thisTemp.CB["definitionPB"];
                    var tempWidth = tempELe.offsetWidth,
                        tempHeight = tempELe.offsetHeight;

                    var x =
                        (tempWidth - tbCss["triangleWidth"]) * 0.5 +
                        tbCss["triangleDeviationX"];
                    var y = tempELe.offsetHeight + tbCss["triangleDeviationY"];
                    var cssTemp = {
                        left: x + "px",
                        top: y + "px",
                    };
                    thisTemp.css(thisTemp.CB["definitionTriangle"], cssTemp);
                } else {
                    thisTemp.css(thisTemp.CB["definitionP"], "display", "none");
                }
            };
            this.addListenerInside("click", defClick, this.CB["definition"]);
            var defMouseOut = function (event) {
                if (setTimeOutP) {
                    window.clearTimeout(setTimeOutP);
                    setTimeOutP = null;
                }
                setTimeOutP = setTimeout(function (event) {
                    thisTemp.css(thisTemp.CB["definitionP"], "display", "none");
                }, 500);
            };
            this.addListenerInside(
                "mouseout",
                defMouseOut,
                thisTemp.CB["definitionP"],
            );
            var defMouseOver = function (event) {
                thisTemp.buttonHide = false;
                if (setTimeOutP) {
                    window.clearTimeout(setTimeOutP);
                    setTimeOutP = null;
                }
            };
            this.addListenerInside(
                "mouseover",
                defMouseOver,
                thisTemp.CB["definitionP"],
            );
        },
        /*
			接口函数
			提供给外部api
		*/
        changeDefinition: function (n) {
            if (!this.loaded || n < 0) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.changeDefinition(n);
                return;
            }
            if (this.VA.length > n) {
                var arr = this.VA[n];
                if (arr.length > 3) {
                    var title = arr[2];
                    if (title) {
                        this.newDefinition(title);
                    }
                }
            }
        },
        /*
			内部函数
			切换清晰度后发生的动作
		*/
        newDefinition: function (title) {
            var vArr = this.VA;
            var nVArr = [];
            var i = 0;
            for (i = 0; i < vArr.length; i++) {
                var v = vArr[i];
                if (v[2] == title) {
                    nVArr.push(v);
                    this.sendJS("definitionChange", i + "");
                }
            }
            if (nVArr.length < 1) {
                return;
            }
            if (this.V != null && this.needSeek == 0) {
                this.needSeek = this.V.currentTime;
            }
            if (this.getFileExt(nVArr[0][0]) != ".m3u8") {
                this.isM3u8 = false;
            }
            if (!this.isM3u8) {
                if (nVArr.length == 1) {
                    this.V.innerHTML = "";
                    this.V.src = nVArr[0][0];
                    this.V.currentSrc = nVArr[0][0];
                } else {
                    var source = "";
                    nVArr = this.arrSort(nVArr);
                    for (i = 0; i < nVArr.length; i++) {
                        var type = "";
                        var va = nVArr[i];
                        if (va[1]) {
                            type = ' type="' + va[1] + '"';
                        }
                        source += '<source src="' + va[0] + '"' + type + ">";
                    }
                    this.V.removeAttribute("src");
                    this.V.innerHTML = source;
                    this.V.currentSrc = nVArr[0][0];
                }
            } else {
                this.embedHls(vArr[0][0], this.vars["autoplay"]);
            }
            this.V.autoplay = "autoplay";
            this.V.load();
            if (this.playbackRateTemp != 1) {
                this.V.playbackRate = this.playbackRateTemp; //定义倍速
            }
            this.timerErrorFun();
        },
        /*
			内置函数
			播放hls
		*/
        embedHls: function (url, autoplay) {
            var thisTemp = this;
            thisTemp.hlsAutoPlay = autoplay;
            if (Hls.isSupported()) {
                var hls = new Hls();
                hls.loadSource(url);
                hls.attachMedia(this.V);
                hls.on(Hls.Events.MANIFEST_PARSED, function () {
                    thisTemp.playerLoad();
                    if (autoplay) {
                        thisTemp.videoPlay();
                    }
                });
            }
        },
        /*
			内部函数
			构建提示点
		*/
        prompt: function () {
            if (!this.conBarShow) {
                return;
            }
            var thisTemp = this;
            var prompt = this.vars["promptSpot"];
            if (prompt == null || this.promptArr.length > 0) {
                return;
            }
            var showPrompt = function (event) {
                if (thisTemp.promptElement == null) {
                    var random2 = "prompte-" + thisTemp.randomString(5);
                    var ele2 = document.createElement("div");
                    ele2.className = random2;
                    thisTemp.PD.appendChild(ele2);
                    thisTemp.promptElement = thisTemp.getByElement(random2);
                    thisTemp.css(thisTemp.promptElement, {
                        overflowX: "hidden",
                        lineHeight: thisTemp.ckStyle["previewPrompt"]["lineHeight"] + "px",
                        fontFamily: thisTemp.ckStyle["previewPrompt"]["font"],
                        fontSize: thisTemp.ckStyle["previewPrompt"]["size"] + "px",
                        color: thisTemp.ckStyle["previewPrompt"]["color"].replace(
                            "0x",
                            "#",
                        ),
                        position: "absolute",
                        display: "block",
                        zIndex: "90",
                    });
                }
                var pcon = thisTemp.getPromptTest();
                var pW = pcon["pW"],
                    pT = pcon["pT"],
                    pL = parseInt(thisTemp.css(this, "left")) - parseInt(pW * 0.5);
                if (pcon["pL"] > 10) {
                    pL = pcon["pL"];
                }
                if (pL < 0) {
                    pL = 0;
                }
                thisTemp.css(thisTemp.promptElement, {
                    width: pW + "px",
                    left: -pW - 10 + "px",
                    display: "block",
                });
                thisTemp.promptElement.innerHTML = thisTemp.getDataset(this, "words");
                thisTemp.css(thisTemp.promptElement, {
                    left: pL + "px",
                    top:
                        pT -
                        thisTemp.promptElement.offsetHeight -
                        thisTemp.ckStyle["previewPrompt"]["marginBottom"] +
                        "px",
                });
            };
            var hidePrompt = function (event) {
                if (thisTemp.promptElement != null) {
                    thisTemp.css(thisTemp.promptElement, {
                        display: "none",
                    });
                }
            };
            var i = 0;
            for (i = 0; i < prompt.length; i++) {
                var pr = prompt[i];
                var words = pr["words"];
                var time = pr["time"];
                var random = "prompttitle-" + this.randomString(5);
                var ele = document.createElement("div");
                ele.className = random;
                this.CB["timeBoBg"].appendChild(ele);
                var div = this.getByElement(random);
                try {
                    div.setAttribute("data-time", time);
                    if (this.ckConfig["config"]["promptSpotTime"]) {
                        words =
                            this.formatTime(time, 0, this.ckLanguage["timeSliderOver"]) +
                            " " +
                            words;
                    }
                    div.setAttribute("data-words", words);
                } catch (event) {
                }
                var pCss = this.getEleCss(this.ckStyle["promptSpotH5"], {
                    marginY: -10000,
                    zIndex: 1,
                });
                try {
                    this.css(div, pCss);
                } catch (event) {
                }
                this.addListenerInside("mouseover", showPrompt, div);
                this.addListenerInside("mouseout", hidePrompt, div);
                this.promptArr.push(div);
            }
            this.changePrompt();
        },
        /*
			内部函数
			计算提示文本的位置
		*/
        getPromptTest: function () {
            var pW = this.previewWidth,
                pT = this.getCoor(this.CB["timeProgressBg"])["y"],
                pL = 0;
            if (this.previewTop != null) {
                pT = parseInt(this.css(this.previewTop, "top"));
                pL = parseInt(this.css(this.previewTop, "left"));
            } else {
                pT -= 35;
            }
            pL += 2;
            if (pL < 0) {
                pL = 0;
            }
            if (pL > this.PD.offsetWidth - pW) {
                pL = this.PD.offsetWidth - pW;
            }
            return {
                pW: pW,
                pT: pT,
                pL: pL,
            };
        },
        /*
			内部函数
			删除提示点
		*/
        deletePrompt: function () {
            var arr = this.promptArr;
            if (arr.length > 0) {
                for (var i = 0; i < arr.length; i++) {
                    if (arr[i]) {
                        this.deleteChild(arr[i]);
                    }
                }
            }
            this.promptArr = [];
        },
        /*
			内部函数
			计算提示点坐标
		*/
        changePrompt: function () {
            if (this.promptArr.length == 0) {
                return;
            }
            var arr = this.promptArr;
            var duration = this.getMetaDate()["duration"];
            var bw = this.CB["timeBoBg"].offsetWidth;
            for (var i = 0; i < arr.length; i++) {
                var time = parseInt(this.getDataset(arr[i], "time"));
                var left =
                    parseInt((time * bw) / duration) - parseInt(arr[i].offsetWidth * 0.5);
                if (left < 0) {
                    left = 0;
                }
                if (left > bw - parseInt(arr[i].offsetWidth * 0.5)) {
                    left = bw - parseInt(arr[i].offsetWidth * 0.5);
                }
                this.css(arr[i], {
                    left: left + "px",
                    display: "block",
                });
            }
        },
        /*
			内部函数
			构建预览图片效果
		*/
        preview: function (obj) {
            var thisTemp = this;
            var preview = {
                file: null,
                scale: 0,
            };
            preview = this.standardization(preview, this.vars["preview"]);
            if (preview["file"] == null || preview["scale"] <= 0) {
                return;
            }
            var srcArr = preview["file"];
            if (this.previewStart == 0) {
                //如果还没有构建，则先进行构建
                this.previewStart = 1;
                if (srcArr.length > 0) {
                    var i = 0;
                    var imgW = 0,
                        imgH = 0;
                    var random = "preview-" + thisTemp.randomString(10);
                    var loadNum = 0;
                    var loadImg = function (i) {
                        srcArr[i] = thisTemp.getNewUrl(srcArr[i]);
                        var n = 0;
                        var img = new Image();
                        img.src = srcArr[i];
                        img.className = random + i;
                        img.onload = function (event) {
                            loadNum++;
                            if (thisTemp.previewDiv == null) {
                                //如果没有建立DIV，则建
                                imgW = img.width;
                                imgH = img.height;
                                thisTemp.previewWidth = parseInt(imgW * 0.1);
                                var ele = document.createElement("div");
                                ele.className = random;
                                thisTemp.PD.appendChild(ele);
                                thisTemp.previewDiv = thisTemp.getByElement(random);
                                var eleTop = 0;
                                eleTop =
                                    thisTemp.PD.offsetHeight -
                                    thisTemp.ckStyle["preview"]["bottom"];
                                thisTemp.css(thisTemp.previewDiv, {
                                    width: srcArr.length * imgW * 10 + "px",
                                    height: parseInt(imgH * 0.1) + "px",
                                    backgroundColor: "#000000",
                                    position: "absolute",
                                    left: "0px",
                                    top: eleTop + "px",
                                    display: "none",
                                    zIndex: "80",
                                });
                                ele.setAttribute("data-x", "0");
                                ele.setAttribute("data-y", eleTop);
                                var ele2 = document.createElement("div");
                                ele2.className = random + "d2";
                                thisTemp.PD.appendChild(ele2);
                                thisTemp.previewTop = thisTemp.getByElement(ele2.className);
                                thisTemp.css(thisTemp.previewTop, {
                                    width: parseInt(imgW * 0.1) + "px",
                                    height: parseInt(imgH * 0.1) + "px",
                                    position: "absolute",
                                    border:
                                        thisTemp.ckStyle["preview"]["border"] +
                                        "px solid " +
                                        thisTemp.ckStyle["preview"]["borderColor"].replace(
                                            "0x",
                                            "#",
                                        ),
                                    left: "0px",
                                    top: eleTop + "px",
                                    display: "none",
                                    zIndex: "81",
                                });
                                var html = "";
                                for (n = 0; n < srcArr.length; n++) {
                                    html += thisTemp.newCanvas(
                                        random + n,
                                        imgW * 10,
                                        parseInt(imgH * 0.1),
                                    );
                                }
                                thisTemp.previewDiv.innerHTML = html;
                            }
                            thisTemp.previewDiv.appendChild(img);
                            var cimg = thisTemp.getByElement(img.className);
                            var canvas = thisTemp.getByElement(img.className + "-canvas");
                            var context = canvas.getContext("2d");
                            var sx = 0,
                                sy = 0,
                                x = 0,
                                h = parseInt(imgH * 0.1);
                            for (n = 0; n < 100; n++) {
                                x = parseInt(n * imgW * 0.1);
                                context.drawImage(
                                    cimg,
                                    sx,
                                    sy,
                                    parseInt(imgW * 0.1),
                                    h,
                                    x,
                                    0,
                                    parseInt(imgW * 0.1),
                                    h,
                                );
                                sx += parseInt(imgW * 0.1);
                                if (sx >= imgW) {
                                    sx = 0;
                                    sy += h;
                                }
                                thisTemp.css(cimg, "display", "none");
                            }
                            if (loadNum == srcArr.length) {
                                thisTemp.previewStart = 2;
                            } else {
                                i++;
                                loadImg(i);
                            }
                        };
                    };
                }
                loadImg(i);
                return;
            }
            if (this.previewStart == 2) {
                var isTween = true;
                var nowNum = parseInt(obj["time"] / this.vars["preview"]["scale"]);
                var numTotal = parseInt(
                    thisTemp.getMetaDate()["duration"] / this.vars["preview"]["scale"],
                );
                if (thisTemp.css(thisTemp.previewDiv, "display") == "none") {
                    isTween = false;
                }
                thisTemp.css(thisTemp.previewDiv, "display", "block");
                var imgWidth = (thisTemp.previewDiv.offsetWidth * 0.01) / srcArr.length;
                var left = imgWidth * nowNum - obj["x"] + parseInt(imgWidth * 0.5),
                    top =
                        thisTemp.PD.offsetHeight -
                        thisTemp.previewDiv.offsetHeight -
                        thisTemp.ckStyle["preview"]["bottom"];
                thisTemp.css(thisTemp.previewDiv, "top", top + 2 + "px");
                var topLeft = obj["x"] - parseInt(imgWidth * 0.5);
                var timepieces = 0;
                if (topLeft < 0) {
                    topLeft = 0;
                    timepieces = obj["x"] - topLeft - imgWidth * 0.5;
                }
                if (topLeft > thisTemp.PD.offsetWidth - imgWidth) {
                    topLeft = thisTemp.PD.offsetWidth - imgWidth;
                    timepieces = obj["x"] - topLeft - imgWidth * 0.5;
                }
                if (left < 0) {
                    left = 0;
                }
                if (left > numTotal * imgWidth - thisTemp.PD.offsetWidth) {
                    left = numTotal * imgWidth - thisTemp.PD.offsetWidth;
                }
                thisTemp.css(thisTemp.previewTop, {
                    left: topLeft + "px",
                    top: top + 2 + "px",
                    display: "block",
                });
                if (
                    thisTemp.previewTop.offsetHeight > thisTemp.previewDiv.offsetHeight
                ) {
                    thisTemp.css(thisTemp.previewTop, {
                        height:
                            thisTemp.previewDiv.offsetHeight -
                            (thisTemp.previewTop.offsetHeight -
                                thisTemp.previewDiv.offsetHeight) +
                            "px",
                    });
                }
                if (this.previewTween != null) {
                    this.animatePause(this.previewTween);
                    this.previewTween = null;
                }
                var nowLeft = parseInt(thisTemp.css(thisTemp.previewDiv, "left"));
                var leftC = nowLeft + left;
                if (nowLeft == -(left + timepieces)) {
                    return;
                }
                if (isTween) {
                    var obj = {
                        element: thisTemp.previewDiv,
                        start: null,
                        end: -(left + timepieces),
                        speed: 0.3,
                    };
                    this.previewTween = this.animate(obj);
                } else {
                    thisTemp.css(
                        thisTemp.previewDiv,
                        "left",
                        -(left + timepieces) + "px",
                    );
                }
            }
        },
        /*
			内部函数
			删除预览图节点
		*/
        deletePreview: function () {
            if (this.previewDiv != null) {
                this.deleteChild(this.previewDiv);
                this.previewDiv = null;
                this.previewStart = 0;
            }
        },
        /*
			内部函数
			修改视频地址，属性
		*/
        changeVideo: function () {
            if (!this.html5Video) {
                this.getVarsObject();
                this.V.newVideo(this.vars);
                return;
            }
            var vArr = this.VA;
            var v = this.vars;
            var i = 0;
            if (vArr.length < 1) {
                return;
            }
            if (this.V != null && this.needSeek == 0) {
                this.needSeek = this.V.currentTime;
            }
            if (v["poster"]) {
                this.V.poster = v["poster"];
            } else {
                this.V.removeAttribute("poster");
            }
            if (v["loop"]) {
                this.V.loop = "loop";
            } else {
                this.V.removeAttribute("loop");
            }
            if (v["seek"] > 0) {
                this.needSeek = v["seek"];
            } else {
                this.needSeek = 0;
            }
            if (this.getFileExt(vArr[0][0]) != ".m3u8") {
                this.isM3u8 = false;
            }
            if (!this.isM3u8) {
                if (vArr.length == 1) {
                    this.V.innerHTML = "";
                    this.V.src = vArr[0][0];
                } else {
                    var source = "";
                    vArr = this.arrSort(vArr);
                    for (i = 0; i < vArr.length; i++) {
                        var type = "";
                        var va = vArr[i];
                        if (va[1]) {
                            type = ' type="' + va[1] + '"';
                        }
                        source += '<source src="' + va[0] + '"' + type + ">";
                    }
                    this.V.removeAttribute("src");
                    this.V.innerHTML = source;
                }
                //分析视频地址结束
                if (v["autoplay"]) {
                    this.V.autoplay = "autoplay";
                } else {
                    this.V.removeAttribute("autoplay");
                }
                this.V.load();
            } else {
                this.embedHls(vArr[0][0], v["autoplay"]);
            }
            if (!this.isUndefined(v["volume"])) {
                this.changeVolume(v["volume"]);
            }
            this.resetPlayer(); //重置界面元素
            this.timerErrorFun();
            //如果存在字幕则加载
            if (this.vars["cktrack"]) {
                this.loadTrack();
            }
        },
        /*
			内部函数
			调整中间暂停按钮,缓冲loading，错误提示文本框的位置
		*/
        elementCoordinate: function () {
            this.pdCoor = this.getXY(this.PD);
            var cssTemp = null;
            try {
                cssTemp = this.getEleCss(this.ckStyle["centerPlay"], {
                    cursor: "pointer",
                });
                this.css(this.CB["pauseCenter"], cssTemp);
            } catch (event) {
                this.log(event);
            }
            try {
                cssTemp = this.getEleCss(this.ckStyle["loading"]);
                this.css(this.CB["loading"], cssTemp);
            } catch (event) {
                this.log(event);
            }
            try {
                cssTemp = this.getEleCss(this.ckStyle["error"]);
                this.css(this.CB["errorText"], cssTemp);
            } catch (event) {
                this.log(event);
            }
            try {
                cssTemp = this.getEleCss(this.ckStyle["logo"]);
                this.css(this.CB["logo"], cssTemp);
            } catch (event) {
                this.log(event);
            }
            this.checkBarWidth();
        },
        /*
			内部函数
			控制栏内各按钮的位置
		*/
        carbarButton: function () {
            var styleC = this.ckStyle["controlBar"];
            var styleCB = styleC["button"];
            var cssTemp = null;
            var cssSup = {overflow: "hidden", cursor: "pointer", zIndex: 1};
            var cssSup2 = {overflow: "hidden", cursor: "default", zIndex: 1};
            var cssSup4 = {
                overflow: "hidden",
                cursor: "pointer",
                display: "none",
                zIndex: 995,
            };
            //播放/暂停按钮
            cssTemp = this.getEleCss(
                styleCB["play"],
                cssSup,
                this.CB["controlBarBg"],
            );
            this.css(this.CB["play"], cssTemp);
            cssTemp = this.getEleCss(
                styleCB["pause"],
                cssSup,
                this.CB["controlBarBg"],
            );
            this.css(this.CB["pause"], cssTemp);
            //设置静音/取消静音的按钮样式
            cssTemp = this.getEleCss(
                styleCB["mute"],
                cssSup,
                this.CB["controlBarBg"],
            );
            this.css(this.CB["mute"], cssTemp);
            cssTemp = this.getEleCss(
                styleCB["escMute"],
                cssSup,
                this.CB["controlBarBg"],
            );
            this.css(this.CB["escMute"], cssTemp);
            //设置全屏/退出全屏按钮样式
            cssTemp = this.getEleCss(
                styleCB["full"],
                cssSup,
                this.CB["controlBarBg"],
            );
            this.css(this.CB["full"], cssTemp);
            cssTemp = this.getEleCss(
                styleCB["escFull"],
                cssSup,
                this.CB["controlBarBg"],
            );
            this.css(this.CB["escFull"], cssTemp);
            cssTemp = this.getEleCss(
                styleC["timeText"]["vod"],
                cssSup2,
                this.CB["controlBarBg"],
            );
            this.css(this.CB["timeText"], cssTemp);
            //音量调节框
            var volumeSchedule = this.newObj(styleC["volumeSchedule"]);
            volumeSchedule["backgroundImg"] = "";
            cssTemp = this.getEleCss(
                volumeSchedule,
                cssSup2,
                this.CB["controlBarBg"],
            );
            this.css(this.CB["volume"], cssTemp);
            cssTemp = {
                width: cssTemp["width"],
                height: styleC["volumeSchedule"]["backgroundHeight"] + "px",
                overflow: "hidden",
                backgroundRepeat: "no-repeat",
                backgroundPosition: "left center",
            };
            if (this.ckConfig["config"]["buttonMode"]["volumeSchedule"]) {
                cssTemp["cursor"] = "pointer";
            }
            this.css(this.CB["volumeBg"], cssTemp);
            this.css(this.CB["volumeBg"], {
                position: "absolute",
            });
            cssTemp["width"] =
                this.CB["volumeBO"].offsetWidth * 0.5 +
                parseInt(this.css(this.CB["volumeBO"], "left")) +
                "px";
            this.css(this.CB["volumeUp"], cssTemp);
            this.css(
                this.CB["volumeBg"],
                "backgroundImage",
                "url(" + styleC["volumeSchedule"]["backgroundImg"] + ")",
            );
            this.css(
                this.CB["volumeUp"],
                "backgroundImage",
                "url(" + styleC["volumeSchedule"]["maskImg"] + ")",
            );
            //音量调节按钮
            cssTemp = this.getEleCss(styleC["volumeSchedule"]["button"], {
                overflow: "hidden",
                cursor: "pointer",
                backgroundRepeat: "no-repeat",
                backgroundPosition: "left center",
            });
            this.css(this.CB["volumeBO"], cssTemp);
            //倍速容器
            if (this.ckConfig["config"]["playbackRate"]) {
                if (!this.CB["playbackrateButtonText"]) {
                    this.textButton(
                        this.CB["playbackrate"],
                        styleC["playbackrate"]["defaultButton"],
                        this.objectAssign(
                            {
                                overflow: "hidden",
                                cursor: "pointer",
                                zIndex: 1,
                            },
                            styleC["playbackrate"]["defaultButtonCoor"],
                        ),
                        this.CB["controlBarBg"],
                        this.ckLanguage["playbackrate"],
                        "playbackrateButtonText",
                    );
                }
                cssTemp = this.getEleCss(
                    styleC["playbackrate"]["defaultButtonCoor"],
                    cssSup,
                    this.CB["controlBarBg"],
                );
                this.css(this.CB["playbackrate"], {
                    left: cssTemp["left"],
                    top: cssTemp["top"],
                });
                this.css(this.CB["playbackrateP"], "display", "none");
                cssTemp = this.getEleCss(
                    styleC["playbackrate"]["backgroundCoorH5"],
                    cssSup4,
                );
                this.css(this.CB["playbackrateP"], cssTemp);
            }
            //初始化清晰度按钮
            if (this.ckConfig["config"]["definition"]) {
                if (!this.CB["defaultButtonText"]) {
                    this.textButton(
                        this.CB["definition"],
                        styleC["definition"]["defaultButton"],
                        this.objectAssign(
                            {
                                overflow: "hidden",
                                cursor: "pointer",
                                zIndex: 1,
                            },
                            styleC["definition"]["defaultButtonCoor"],
                        ),
                        this.CB["controlBarBg"],
                        this.ckLanguage["definition"],
                        "defaultButtonText",
                    );
                }
                cssTemp = this.getEleCss(
                    styleC["definition"]["defaultButtonCoor"],
                    cssSup,
                    this.CB["controlBarBg"],
                );
                this.css(this.CB["definition"], {
                    left: cssTemp["left"],
                    top: cssTemp["top"],
                });
                this.css(this.CB["definitionP"], "display", "none");
                cssTemp = this.getEleCss(
                    styleC["definition"]["backgroundCoorH5"],
                    cssSup4,
                );
                this.css(this.CB["definitionP"], cssTemp);
            }
            //初始化字幕切换按钮
            if (this.ckConfig["config"]["subtitle"]) {
                if (!this.CB["subtitleButtonText"]) {
                    this.textButton(
                        this.CB["subtitles"],
                        styleC["subtitle"]["defaultButton"],
                        this.objectAssign(
                            {
                                overflow: "hidden",
                                cursor: "pointer",
                                zIndex: 1,
                            },
                            styleC["subtitle"]["defaultButtonCoor"],
                        ),
                        this.CB["controlBarBg"],
                        this.ckLanguage["subtitle"],
                        "subtitleButtonText",
                    );
                }
                //字幕按钮列表容器样式
                cssTemp = this.getEleCss(
                    styleC["subtitle"]["defaultButtonCoor"],
                    cssSup,
                    this.CB["controlBarBg"],
                );
                this.css(this.CB["subtitles"], {
                    left: cssTemp["left"],
                    top: cssTemp["top"],
                });
                this.css(this.CB["subtitlesP"], "display", "none");
                cssTemp = this.getEleCss(
                    styleC["subtitle"]["backgroundCoorH5"],
                    cssSup4,
                );
                this.css(this.CB["subtitlesP"], cssTemp);
            }
        },
        /*
		 	构造一个文字按钮
		 	ele:当前按钮
		 	css:样式
		 	cssSup:补充样式
		 	upEle：上一级容器对象
		 	text:显示的文本
		 	newName:文本框名称
		*/
        textButton: function (ele, css, cssSup, upEle, text, newName) {
            var thisTemp = this;
            var bgCss = {
                width: css["width"],
                height: css["height"],
            };
            if (cssSup) {
                bgCss = {
                    width: css["width"],
                    height: css["height"],
                    align: cssSup["align"],
                    vAlign: cssSup["vAlign"],
                    marginX: cssSup["marginX"],
                    marginY: cssSup["marginY"],
                    offsetX: cssSup["offsetX"],
                    offsetY: cssSup["offsetY"],
                    zIndex: 2,
                };
            }
            cssTemp = this.getEleCss(bgCss, null, upEle);
            thisTemp.css(ele, cssTemp);
            var outCss = this.newObj(css);
            var overCss = this.newObj(css);
            var textOutCss = this.newObj(css);
            var textOverCss = this.newObj(css);
            var cssTemp = null;
            outCss["alpha"] = css["backgroundAlpha"];
            overCss["backgroundColor"] = css["overBackgroundColor"];
            overCss["alpha"] = css["backgroundAlpha"];
            textOutCss["color"] = css["textColor"];
            textOverCss["color"] = css["overTextColor"];
            textOutCss["textAlign"] = css["align"];
            textOverCss["textAlign"] = css["align"];
            //修正文字
            textOutCss["backgroundColor"] = textOverCss["backgroundColor"] = "";
            var bgEle = document.createElement("div"); //按钮背景层
            this.removeChildAll(ele);
            ele.appendChild(bgEle);
            if (newName) {
                this.CB[newName] = document.createElement("div"); //文字层
                ele.appendChild(this.CB[newName]);
                this.CB[newName].innerHTML = text;
            } else {
                var newEle = document.createElement("div"); //文字层
                ele.appendChild(newEle);
                newEle.innerHTML = text;
            }
            var outFun = function () {
                cssTemp = thisTemp.getEleCss(
                    outCss,
                    {
                        cursor: "pointer",
                        zIndex: 1,
                    },
                    bgEle,
                );
                cssTemp["left"] = "";
                cssTemp["top"] = "";
                thisTemp.css(bgEle, cssTemp);
                cssTemp = thisTemp.getEleCss(
                    textOutCss,
                    {
                        cursor: "pointer",
                        zIndex: 2,
                    },
                    bgEle,
                );
                cssTemp["left"] = "";
                cssTemp["top"] = "";
                if (newName) {
                    thisTemp.css(thisTemp.CB[newName], cssTemp, bgEle);
                } else {
                    thisTemp.css(newEle, cssTemp, bgEle);
                }
                thisTemp.buttonHide = true; //显示的列表框需要隐藏
                if (thisTemp.timeButtonOver) {
                    window.clearTimeout(thisTemp.timeButtonOver);
                    thisTemp.timeButtonOver = null;
                }
                thisTemp.timeButtonOver = window.setTimeout(function () {
                    thisTemp.buttonListHide();
                }, 1000);
            };
            var overFun = function () {
                cssTemp = thisTemp.getEleCss(overCss, {zIndex: 1}, bgEle);
                cssTemp["left"] = "";
                cssTemp["top"] = "";
                thisTemp.css(bgEle, cssTemp);
                cssTemp = thisTemp.getEleCss(textOverCss, {zIndex: 2}, bgEle);
                cssTemp["left"] = "";
                cssTemp["top"] = "";
                if (newName) {
                    thisTemp.css(thisTemp.CB[newName], cssTemp);
                } else {
                    thisTemp.css(newEle, cssTemp);
                }
            };
            outFun();
            this.addListenerInside("mouseout", outFun, ele);
            this.addListenerInside("mouseover", overFun, ele);
        },
        /*
			隐藏所有的列表框
		*/
        buttonListHide: function () {
            if (this.buttonHide) {
                this.css(
                    [
                        this.CB["definitionP"],
                        this.CB["subtitlesP"],
                        this.CB["playbackrateP"],
                    ],
                    "display",
                    "none",
                );
            }
            if (this.timeButtonOver) {
                window.clearTimeout(this.timeButtonOver);
                this.timeButtonOver = null;
            }
            this.buttonHide = false;
        },
        /*
		 	计算视频的宽高
		*/
        videoCss: function () {
            var cssTemp = {};

            if (this.css(this.CB["controlBar"], "display") == "none") {
                cssTemp = this.ckStyle["video"]["controlBarHideReserve"];
            } else {
                cssTemp = this.ckStyle["video"]["reserve"];
            }
            var spacingBottom = cssTemp["spacingBottom"];
            if (this.V.controls && this.isMobile()) {
                spacingBottom -= 40;
            }
            var pW = this.PD.offsetWidth,
                pH = this.PD.offsetHeight;
            var vW = pW - cssTemp["spacingLeft"] - cssTemp["spacingRight"];
            var vH = pH - cssTemp["spacingTop"] - spacingBottom;
            if (!this.MD) {
                this.css(this.V, {
                    width: vW + "px",
                    height: vH + "px",
                    marginLeft: cssTemp["spacingLeft"] + "px",
                    marginTop: cssTemp["spacingTop"] + "px",
                });
            } else {
                this.css([this.MD, this.MDC], {
                    width: vW + "px",
                    height: vH + "px",
                    marginLeft: cssTemp["spacingLeft"] + "px",
                    marginTop: cssTemp["spacingTop"] + "px",
                });
            }
        },
        /*
		 	播放器界面自定义元素
		*/
        playerCustom: function () {
            var custom = this.ckStyle["custom"];
            var button = custom["button"];
            var images = custom["images"];
            var cssTemp = null;
            var cssSup = null;
            var k = "",
                tempID = "";
            var b = {};
            var tempDiv;
            var i = 0;
            for (k in button) {
                b = button[k];
                cssSup = {overflow: "hidden", cursor: "pointer", zIndex: 1};
                cssTemp = this.getEleCss(b, cssSup);
                tempDiv = document.createElement("div");
                this.css(tempDiv, cssTemp);
                this.customeElement.push({
                    ele: tempDiv,
                    css: b,
                    cssSup: cssSup,
                    type: "player-button",
                    name: k,
                });
                this.PD.appendChild(tempDiv);
                if (!this.isUndefined(this.ckLanguage["buttonOver"][k])) {
                    tempDiv.dataset.title = this.ckLanguage["buttonOver"][k];
                }
                i++;
                this.buttonEventFun(tempDiv, b);
            }
            if (!!images)
                for (k in images) {
                    b = images[k];
                    cssSup = {overflow: "hidden", zIndex: 1};
                    cssTemp = this.getEleCss(b, cssSup);
                    tempDiv = document.createElement("div");
                    this.css(tempDiv, cssTemp);
                    this.customeElement.push({
                        ele: tempDiv,
                        css: b,
                        cssSup: cssSup,
                        type: "player-images",
                        name: k,
                    });
                    this.PD.appendChild(tempDiv);
                    var img = new Image();
                    img.src = images[k]["img"];
                    tempDiv.appendChild(img);
                    i++;
                }
        },
        /*
		 	控制栏自定义元素
		*/
        carbarCustom: function () {
            var custom = this.ckStyle["controlBar"]["custom"];
            var button = custom["button"];
            var images = custom["images"];
            var cssTemp = null;
            var cssSup = null;
            var k = "",
                tempID = "";
            var b = {};
            var tempDiv;
            var i = 0;
            for (k in button) {
                b = button[k];
                cssSup = {overflow: "hidden", cursor: "pointer", zIndex: 1};
                cssTemp = this.getEleCss(b, cssSup, this.CB["controlBarBg"]);
                tempDiv = document.createElement("div");
                this.css(tempDiv, cssTemp);
                this.customeElement.push({
                    ele: tempDiv,
                    css: b,
                    cssSup: cssSup,
                    type: "controlBar-button",
                    name: k,
                });
                this.CB["controlBar"].appendChild(tempDiv);
                if (!this.isUndefined(this.ckLanguage["buttonOver"][k])) {
                    tempDiv.dataset.title = this.ckLanguage["buttonOver"][k];
                }
                i++;
                this.buttonEventFun(tempDiv, b);
            }
            for (k in images) {
                b = images[k];
                cssSup = {overflow: "hidden", zIndex: 1};
                cssTemp = this.getEleCss(b, cssSup, this.CB["controlBarBg"]);
                tempDiv = document.createElement("div");
                this.css(tempDiv, cssTemp);
                this.customeElement.push({
                    ele: tempDiv,
                    css: b,
                    cssSup: cssSup,
                    type: "controlBar-images",
                    name: k,
                });
                this.CB["controlBar"].appendChild(tempDiv);
                var img = new Image();
                img.src = images[k]["img"];
                tempDiv.appendChild(img);
                i++;
            }
        },
        /*
		 	控制栏自定义元素的位置
		*/
        customCoor: function () {
            var cssTemp = null;
            if (this.customeElement.length > 0) {
                for (var i = 0; i < this.customeElement.length; i++) {
                    if (this.customeElement[i]["type"] == "controlBar") {
                        cssTemp = this.getEleCss(
                            this.customeElement[i]["css"],
                            this.customeElement[i]["cssSup"],
                            this.CB["controlBarBg"],
                        );
                    } else {
                        cssTemp = this.getEleCss(
                            this.customeElement[i]["css"],
                            this.customeElement[i]["cssSup"],
                        );
                    }
                    this.css(this.customeElement[i]["ele"], cssTemp);
                }
            }
        },
        /*
		 	控制栏自定义元素的显示和隐藏，只对播放器界面的有效，作用是当播放视频广告时隐藏，广告播放完成后显示
		*/
        customShow: function (show) {
            if (this.customeElement.length > 0) {
                for (var i = 0; i < this.customeElement.length; i++) {
                    if (this.customeElement[i]["type"] == "player") {
                        this.css(
                            this.customeElement[i]["ele"],
                            "display",
                            show ? "block" : "none",
                        );
                    }
                }
            }
        },
        /*
		 	广告控制栏样式
		*/
        advertisementStyle: function () {
            var asArr = [
                "muteButton",
                "escMuteButton",
                "adLinkButton",
                "closeButton",
                "skipAdButton",
                "countDown",
                "countDownText",
                "skipDelay",
                "skipDelayText",
            ];
            var eleArr = [
                "adMute",
                "adEscMute",
                "adLink",
                "adPauseClose",
                "adSkipButton",
                "adTime",
                "adTimeText",
                "adSkip",
                "adSkipText",
            ];
            for (var i = 0; i < eleArr.length; i++) {
                var cssUp = {overflow: "hidden", zIndex: 999};
                if (i < 5) {
                    cssUp["cursor"] = "pointer";
                }
                var cssTemp = this.getEleCss(
                    this.ckStyle["advertisement"][asArr[i]],
                    cssUp,
                );
                this.css(this.CB[eleArr[i]], cssTemp);
            }
        },
        /*
			内部函数
			当播放器尺寸变化时，显示和隐藏相关节点
		*/
        checkBarWidth: function () {
            if (!this.conBarShow) {
                return;
            }
        },
        /*
			内部函数
			初始化暂停或播放按钮
		*/
        initPlayPause: function () {
            if (!this.conBarShow) {
                return;
            }
            if (this.vars["autoplay"]) {
                this.css([this.CB["play"], this.CB["pauseCenter"]], "display", "none");
                this.css(this.CB["pause"], "display", "block");
            } else {
                this.css(this.CB["play"], "display", "block");
                if (this.css(this.CB["errorText"], "display") == "none") {
                    this.css(this.CB["pauseCenter"], "display", "block");
                }
                this.css(this.CB["pause"], "display", "none");
            }
        },

        /*
			下面为监听事件
			内部函数
			监听元数据已加载
		*/
        loadedHandler: function () {
            this.loaded = true;
            if (this.vars["loaded"] != "") {
                try {
                    eval(this.vars["loaded"] + "('" + this.vars["variable"] + "')");
                } catch (event) {
                    this.log(event);
                }
            }
        },
        /*
			内部函数
			监听播放
		*/
        playingHandler: function () {
            this.playShow(true);
            //如果是第一次播放
            if (
                this.isFirstTimePlay &&
                !this.isUndefined(this.advertisements["front"])
            ) {
                this.isFirstTimePlay = false;
                //调用播放前置广告组件
                this.adI = 0;
                this.adType = "front";
                this.adMuteInto();
                this.adIsVideoTime = true;
                this.adPlayStart = true;
                this.adVideoPlay = false;
                this.videoPause();
                this.advertisementsTime();
                this.advertisementsPlay();
                this.adSkipButtonShow();
                //调用播放前置广告组件结束
                return;
            }
            if (this.adPlayerPlay) {
                return;
            }
            //判断第一次播放结束
            if (this.needSeek > 0) {
                this.videoSeek(this.needSeek);
                this.needSeek = 0;
            }
            if (this.animatePauseArray.length > 0) {
                this.animateResume("pause");
            }
            if (
                this.playerType == "html5video" &&
                this.V != null &&
                this.ckConfig["config"]["videoDrawImage"]
            ) {
                this.sendVCanvas();
            }
            if (
                !this.isUndefined(this.advertisements["pause"]) &&
                !this.adPlayStart
            ) {
                //如果存在暂停广告
                this.closePauseAd();
            }
        },
        /*暂停时播放暂停广告*/
        adPausePlayer: function () {
            this.adI = 0;
            this.adType = "pause";
            this.adPauseShow = true;
            this.loadAdPause();
            this.sendJS("pauseAd", "play");
        },
        loadAdPause: function () {
            var ad = this.getNowAdvertisements();
            var type = ad["type"];
            var thisTemp = this;
            var width = this.PD.offsetWidth,
                height = this.PD.offsetHeight;
            if (this.isStrImage(type) && this.adPauseShow) {
                this.css(this.CB["adElement"], "display", "block");
                var imgClass = "adimg" + this.randomString(10);
                var imgHtml = '<img src="' + ad["file"] + '" class="' + imgClass + '">';
                if (ad["link"]) {
                    imgHtml =
                        '<a href="' + ad["link"] + '" target="_blank">' + imgHtml + "</a>";
                }
                this.CB["adElement"].innerHTML = imgHtml;
                this.addListenerInside(
                    "load",
                    function () {
                        var imgObj = new Image();
                        imgObj.src = this.src;
                        var imgWH = thisTemp.adjustmentWH(imgObj.width, imgObj.height);
                        thisTemp.css(
                            [thisTemp.getByElement(imgClass), thisTemp.CB["adElement"]],
                            {
                                width: imgWH["width"] + "px",
                                height: imgWH["height"] + "px",
                                border: "0px",
                            },
                        );
                        if (
                            thisTemp.ckStyle["advertisement"]["closeButtonShow"] &&
                            thisTemp.adPauseShow
                        ) {
                            thisTemp.css(thisTemp.CB["adPauseClose"], {
                                display: "block",
                            });
                        }
                        thisTemp.ajaxSuccessNull(ad["exhibitionMonitor"]);
                        thisTemp.adPauseCoor();
                    },
                    this.getByElement(imgClass),
                );
                this.addListenerInside(
                    "click",
                    function () {
                        thisTemp.ajaxSuccessNull(ad["clickMonitor"]);
                    },
                    this.CB["adElement"],
                );
                var newI = this.adI;
                if (this.adI < this.advertisements["pause"].length - 1) {
                    newI++;
                } else {
                    newI = 0;
                }
                if (ad["time"] > 0) {
                    setTimeout(function () {
                        if (thisTemp.adPauseShow) {
                            thisTemp.adI = newI;
                            thisTemp.loadAdPause();
                        }
                    }, ad["time"] * 1000);
                }
            }
        },
        /*调整暂停广告的位置*/
        adPauseCoor: function () {
            if (this.css(this.CB["adElement"], "display") == "block") {
                var w = this.CB["adElement"].offsetWidth,
                    h = this.CB["adElement"].offsetHeight;
                var pw = this.PD.offsetWidth,
                    ph = this.PD.offsetHeight;
                this.css(this.CB["adElement"], {
                    top: (ph - h) * 0.5 + "px",
                    left: (pw - w) * 0.5 + "px",
                });
                if (this.css(this.CB["adPauseClose"], "display") == "block") {
                    var rr = this.ckStyle["advertisement"]["closeButton"];
                    var cxy = this.getPosition(rr, this.CB["adElement"]);
                    this.css(this.CB["adPauseClose"], {
                        top: cxy["y"] + "px",
                        left: cxy["x"] + "px",
                    });
                }
            }
        },
        /*
			关闭暂停广告
		*/
        closePauseAd: function () {
            this.CB["adElement"].innerHTML = "";
            this.css(
                [this.CB["adElement"], this.CB["adPauseClose"]],
                "display",
                "none",
            );
            this.adPauseShow = false;
            this.sendJS("pauseAd", "ended");
        },
        /*计算广告时间*/
        advertisementsTime: function (nt) {
            if (this.isUndefined(nt)) {
                nt = 0;
            }
            var ad = this.advertisements[this.adType];
            if (nt > 0) {
                ad[this.adI]["time"] = Math.ceil(nt);
            }
            this.adTimeAllTotal = 0;
            for (var i = this.adI; i < ad.length; i++) {
                if (!this.isUndefined(ad[i]["time"])) {
                    this.adTimeAllTotal += Math.ceil(ad[i]["time"]);
                }
            }
            if (this.adTimeAllTotal > 0) {
                this.CB["adTimeText"].innerHTML = this.ckLanguage["adCountdown"]
                    .replace("[$second]", this.adTimeAllTotal)
                    .replace(
                        "[$Second]",
                        this.adTimeAllTotal > 9
                            ? this.adTimeAllTotal
                            : "0" + this.adTimeAllTotal,
                    );
            }
            if (this.adPauseShow) {
                this.closePauseAd();
            }
            this.adOtherCloseAll();
            this.adTimeTotal = -1;
        },
        /*判断是否需要显示跳过广告按钮*/
        adSkipButtonShow: function () {
            var thisTemp = this;
            var skipConfig = this.ckStyle["advertisement"];
            var delayTimeTemp = skipConfig[this.adType + "SkipButtonDelay"];
            var timeFun = function () {
                if (delayTimeTemp >= 0) {
                    thisTemp.CB["adSkipText"].innerHTML = thisTemp.ckLanguage["skipDelay"]
                        .replace("[$second]", delayTimeTemp)
                        .replace(
                            "[$Second]",
                            delayTimeTemp > 9 ? delayTimeTemp : "0" + delayTimeTemp,
                        );
                    thisTemp.css(
                        [thisTemp.CB["adSkip"], thisTemp.CB["adSkipText"]],
                        "display",
                        "block",
                    );
                    thisTemp.css(thisTemp.CB["adSkipButton"], "display", "none");
                    setTimeout(timeFun, 1000);
                } else {
                    thisTemp.css(
                        [thisTemp.CB["adSkip"], thisTemp.CB["adSkipText"]],
                        "display",
                        "none",
                    );
                    if (thisTemp.css(thisTemp.CB["adTime"], "display") == "block") {
                        thisTemp.css(thisTemp.CB["adSkipButton"], "display", "block");
                    }
                }
                delayTimeTemp--;
            };
            if (skipConfig["skipButtonShow"]) {
                if (
                    skipConfig[this.adType + "SkipButtonDelay"] > 0 &&
                    this.isUndefined(this.adSkipButtonTime)
                ) {
                    thisTemp.css(
                        [thisTemp.CB["adSkip"], thisTemp.CB["adSkipText"]],
                        "display",
                        "block",
                    );
                    timeFun();
                } else {
                    thisTemp.css(
                        [thisTemp.CB["adSkip"], thisTemp.CB["adSkipText"]],
                        "display",
                        "none",
                    );
                    thisTemp.css(thisTemp.CB["adSkipButton"], "display", "block");
                }
            }
        },
        /*播放广告*/
        advertisementsPlay: function () {
            this.css(
                [
                    this.CB["adBackground"],
                    this.CB["adElement"],
                    this.CB["adTime"],
                    this.CB["adTimeText"],
                    this.CB["adSkip"],
                    this.CB["adSkipText"],
                    this.CB["adSkipButton"],
                    this.CB["adLink"],
                ],
                "display",
                "none",
            );
            this.adPlayerPlay = false;
            var ad = this.advertisements[this.adType];
            if (
                this.adI == 0 &&
                (this.adType == "front" ||
                    this.adType == "insert" ||
                    this.adType == "end")
            ) {
                this.sendJS("process", this.adType + " ad play");
                this.sendJS(this.adType + "Ad", "play");
            }
            this.trackHide();
            if (this.adI < ad.length) {
                if (!this.isUndefined(ad[this.adI]["time"])) {
                    this.adTimeTotal = parseInt(ad[this.adI]["time"]);
                }
                this.loadAdvertisements();
            } else {
                this.adEnded();
            }
        },
        /*清除当前所有广告*/
        eliminateAd: function () {
            if (this.adType) {
                var ad = this.advertisements[this.adType];
                this.adI = ad.length;
                this.advertisementsPlay();
            }
        },
        /*广告播放结束*/
        adEnded: function () {
            var thisTemp = this;
            this.adPlayStart = false;
            if (this.adType == "front") {
                this.time = 0;
            }
            this.adPlayerPlay = false;
            if (this.adVideoPlay) {
                if (this.videoTemp["src"] != "") {
                    this.V.src = this.videoTemp["src"];
                } else {
                    if (this.V.src) {
                        this.V.removeAttribute("src");
                    }
                }
                if (this.videoTemp["source"] != "") {
                    this.V.innerHTML = this.videoTemp["source"];
                }
                if (this.videoTemp["currentSrc"] != "") {
                    this.V.src = this.videoTemp["currentSrc"];
                    this.V.currentSrc = this.videoTemp["currentSrc"];
                }
                if (this.videoTemp["loop"]) {
                    this.V.loop = true;
                    this.videoTemp["loop"] = false;
                }
                if (this.adType == "end") {
                    this.endedHandler();
                } else {
                    this.videoPlay();
                }
            } else {
                this.videoPlay();
            }
            this.changeVolume(this.vars["volume"]);
            this.sendJS("process", this.adType + " ad ended");
            this.sendJS(this.adType + "Ad", "ended");
            this.changeControlBarShow(true);
            this.css(this.CB["logo"], "display", "block");
            this.customShow(true);
            this.css(
                [
                    this.CB["adBackground"],
                    this.CB["adElement"],
                    this.CB["adTime"],
                    this.CB["adTimeText"],
                    this.CB["adSkip"],
                    this.CB["adSkipText"],
                    this.CB["adSkipButton"],
                    this.CB["adLink"],
                    this.CB["adMute"],
                    this.CB["adEscMute"],
                ],
                "display",
                "none",
            );
        },
        /*加载广告*/
        loadAdvertisements: function () {
            //this.videoTemp
            var ad = this.getNowAdvertisements();
            var type = ad["type"];
            var thisTemp = this;
            var width = this.PD.offsetWidth,
                height = this.PD.offsetHeight;
            this.changeControlBarShow(false);
            this.adPlayerPlay = true;
            this.css(this.CB["logo"], "display", "none");
            this.customShow(false);
            if (this.isStrImage(type)) {
                this.css(
                    [
                        this.CB["adBackground"],
                        this.CB["adElement"],
                        this.CB["adTime"],
                        this.CB["adTimeText"],
                    ],
                    "display",
                    "block",
                );
                this.css([this.CB["adMute"], this.CB["adEscMute"]], "display", "none");
                var imgClass = "adimg" + this.randomString(10);
                var imgHtml = '<img src="' + ad["file"] + '" class="' + imgClass + '">';
                if (ad["link"]) {
                    imgHtml =
                        '<a href="' + ad["link"] + '" target="_blank">' + imgHtml + "</a>";
                }
                this.CB["adElement"].innerHTML = imgHtml;
                this.addListenerInside(
                    "load",
                    function () {
                        var imgObj = new Image();
                        imgObj.src = this.src;
                        var imgWH = thisTemp.adjustmentWH(imgObj.width, imgObj.height);
                        thisTemp.css(thisTemp.getByElement(imgClass), {
                            width: imgWH["width"] + "px",
                            height: imgWH["height"] + "px",
                            border: "0px",
                        });
                        thisTemp.css(thisTemp.CB["adElement"], {
                            width: imgWH["width"] + "px",
                            height: imgWH["height"] + "px",
                            top: (height - imgWH["height"]) * 0.5 + "px",
                            left: (width - imgWH["width"]) * 0.5 + "px",
                        });
                        thisTemp.ajaxSuccessNull(ad["exhibitionMonitor"]);
                    },
                    this.getByElement(imgClass),
                );
                this.addListenerInside(
                    "click",
                    function () {
                        thisTemp.ajaxSuccessNull(ad["clickMonitor"]);
                    },
                    this.CB["adElement"],
                );
                if (!this.isUndefined(ad["time"])) {
                    this.adCountDown();
                }
            } else {
                this.css(
                    [this.CB["adTime"], this.CB["adTimeText"]],
                    "display",
                    "block",
                );
                //判断是否静音
                if (this.adVideoMute) {
                    this.css(this.CB["adEscMute"], "display", "block");
                    this.css(this.CB["adMute"], "display", "none");
                } else {
                    this.css(this.CB["adEscMute"], "display", "none");
                    this.css(this.CB["adMute"], "display", "block");
                }
                this.CB["adElement"].innerHTML = "";
                if (this.videoTemp["currentSrc"] == "") {
                    this.videoTemp["currentSrc"] = this.getCurrentSrc();
                }
                if (this.V.loop) {
                    this.videoTemp["loop"] = true;
                    this.V.loop = false;
                }
                if (
                    this.V != null &&
                    this.V.currentTime > 0 &&
                    this.adIsVideoTime &&
                    this.adType != "front"
                ) {
                    //当有视频广告时而又没有记录下已播放的时间则进行记录
                    this.adIsVideoTime = false;
                    this.needSeek = this.V.currentTime;
                }
                this.V.src = ad["file"];
                this.V.currentSrc = ad["file"];
                this.V.innerHTML = "";
                this.V.play();
                this.adVideoPlay = true;
                this.ajaxSuccessNull(ad["exhibitionMonitor"]);
                if (!this.adVideoMute) {
                    this.escAdMute();
                }
            }
            if (ad["link"]) {
                this.css(this.CB["adLink"], "display", "block");
                var adLinkClick = function (event) {
                    thisTemp.sendJS("clickEvent", "javaScript->adLinkClick");
                };
                this.addListenerInside("click", adLinkClick, this.CB["adLink"]);
                this.adLinkTemp = ad["link"];
                var linkTemp =
                    '<a href="' +
                    ad["link"] +
                    '" target="_blank" class="ckadmorelink"><img src="' +
                    this.ckStyle["png-1-1"] +
                    '" width="' +
                    this.ckStyle["advertisement"]["adLinkButton"]["width"] +
                    '" height="' +
                    this.ckStyle["advertisement"]["adLinkButton"]["height"] +
                    '"></a>';
                this.CB["adLink"].innerHTML = linkTemp;
                this.css(this.getByElement("ckadmorelink"), {
                    color: "#FFFFFF",
                    textDecoration: "none",
                });
                this.addListenerInside(
                    "click",
                    function () {
                        thisTemp.ajaxSuccessNull(ad["clickMonitor"]);
                    },
                    this.CB["adLink"],
                );
            } else {
                this.css(this.CB["adLink"], "display", "none");
            }
        },
        /*普通广告倒计时*/
        adCountDown: function () {
            var thisTemp = this;
            if (this.adTimeTotal > 0) {
                if (!this.adIsPause) {
                    this.adTimeTotal--;
                    this.showAdTime();
                    this.adCountDownObj = null;
                    this.adCountDownObj = setTimeout(function () {
                        thisTemp.adCountDown();
                    }, 1000);
                }
            } else {
                this.adI++;
                this.advertisementsPlay();
            }
        },
        /*视频广告倒计时*/
        adPlayerTimeHandler: function (time) {
            var ad = this.getNowAdvertisements();
            var type = ad["type"];
            if (this.isStrImage(type)) {
                return;
            }
            if (this.adTimeTotal != parseInt(time)) {
                this.adTimeTotal = parseInt(time);
                this.showAdTime();
            }
        },
        /*格式化广告倒计时显示*/
        showAdTime: function () {
            this.adTimeAllTotal--;
            var n = this.adTimeAllTotal;
            if (n < 0) {
                n = 0;
            }
            this.CB["adTimeText"].innerHTML = this.ckLanguage["adCountdown"]
                .replace("[$second]", n)
                .replace("[$Second]", n < 10 ? "0" + n : n);
        },
        /*
			单独监听其它广告
		*/
        checkAdOther: function (t) {
            if (this.adPlayerPlay) {
                return;
            }
            var adTime = this.advertisements["othertime"];
            var adPlay = this.advertisements["otherPlay"];
            for (var i = 0; i < adTime.length; i++) {
                if (t >= adTime[i] && !adPlay[i]) {
                    //如果播放时间大于广告时间而该广告还没有播放，则开始播放
                    adPlay[i] = true;
                    this.newAdOther(i);
                }
            }
        },
        /*
			新建其它广告
		*/
        newAdOther: function (i) {
            var thisTemp = this;
            var ad = this.advertisements["other"][i];
            var randomS = this.randomString(10); //获取一个随机字符串
            var adDivID = "adother" + randomS; //广告容器
            imgClassName = "adimgother" + randomS;
            var adDiv = document.createElement("div");
            adDiv.className = adDivID;
            this.PD.appendChild(adDiv);
            ad["div"] = adDivID;
            ad["element"] = imgClassName;
            var adHtml =
                '<img src="' + ad["file"] + '" class="' + imgClassName + '">';
            if (ad["link"]) {
                adHtml =
                    '<a href="' + ad["link"] + '" target="blank">' + adHtml + "</a>";
            }
            this.getByElement(adDivID).innerHTML = adHtml;
            this.css(adDivID, {
                position: "absolute",
                overflow: "hidden",
                zIndex: "996",
                top: "-600px",
                left: "-600px",
                cursor: "pointer",
            });
            if (this.ckStyle["advertisement"]["closeOtherButtonShow"]) {
                var closeAdDivID = "adotherclose-" + randomS; //广告容器
                var closeAdDiv = document.createElement("div");
                closeAdDiv.className = closeAdDivID;
                this.PD.appendChild(closeAdDiv);
                ad["closeDiv"] = closeAdDivID;
                ad["close"] = false;
                var closeAdDivCss = this.getEleCss(
                    this.ckStyle["advertisement"]["closeOtherButton"],
                    {
                        offsetX: -10000,
                        offsetY: -10000,
                        cursor: "pointer",
                        zIndex: 997,
                    },
                );
                this.css(closeAdDivID, closeAdDivCss);
                var adOtherCloseOver = function () {
                    thisTemp.loadImgBg(
                        closeAdDivID,
                        thisTemp.ckStyle["advertisement"]["closeOtherButton"]["mouseOver"],
                    );
                };
                var adOtherCloseOut = function () {
                    thisTemp.loadImgBg(
                        closeAdDivID,
                        thisTemp.ckStyle["advertisement"]["closeOtherButton"]["mouseOut"],
                    );
                };
                adOtherCloseOut();
                this.addListenerInside(
                    "mouseover",
                    adOtherCloseOver,
                    this.getByElement(closeAdDivID),
                );
                this.addListenerInside(
                    "mouseout",
                    adOtherCloseOut,
                    this.getByElement(closeAdDivID),
                );
            }
            this.addListenerInside(
                "load",
                function () {
                    var imgObj = new Image();
                    imgObj.src = this.src;
                    var imgWH = thisTemp.adjustmentWH(imgObj.width, imgObj.height);
                    thisTemp.css(
                        [
                            thisTemp.getByElement(imgClassName),
                            thisTemp.getByElement(adDivID),
                        ],
                        {
                            width: imgWH["width"] + "px",
                            height: imgWH["height"] + "px",
                            border: "0px",
                        },
                    );
                    thisTemp.advertisements["other"][i] = ad;
                    thisTemp.ajaxSuccessNull(ad["exhibitionMonitor"]);
                    thisTemp.adOtherCoor();
                },
                this.getByElement(imgClassName),
            );
            this.addListenerInside(
                "click",
                function () {
                    thisTemp.adOtherClose(i);
                },
                this.getByElement(closeAdDivID),
            );
            this.addListenerInside(
                "click",
                function () {
                    thisTemp.ajaxSuccessNull(ad["clickMonitor"]);
                },
                this.getByElement(imgClassName),
            );
            if (ad["time"] > 0) {
                setTimeout(function () {
                    thisTemp.adOtherClose(i);
                }, ad["time"] * 1000);
            }
        },
        /*
		关闭其它广告
		*/
        adOtherClose: function (i) {
            var ad = this.advertisements["other"][i];
            if (!this.isUndefined(ad["close"])) {
                if (!ad["close"]) {
                    ad["close"] = true;
                    this.PD.removeChild(this.getByElement(ad["div"]));
                    this.PD.removeChild(this.getByElement(ad["closeDiv"]));
                }
            }
        },
        adOtherCloseAll: function () {
            if (!this.isUndefined(this.advertisements["other"])) {
                var ad = this.advertisements["other"];
                for (var i = 0; i < ad.length; i++) {
                    this.adOtherClose(i);
                }
            }
        },
        /*
			计算其它广告的坐标
		*/
        adOtherCoor: function () {
            if (!this.isUndefined(this.advertisements["other"])) {
                var arr = this.advertisements["other"];
                for (var i = 0; i < arr.length; i++) {
                    var ad = arr[i];
                    if (!this.isUndefined(ad["close"])) {
                        if (!ad["close"]) {
                            var rr = this.ckStyle["advertisement"]["closeOtherButton"];
                            var coor = this.getPosition(ad);
                            var x = coor["x"],
                                y = coor["y"];
                            this.css(this.getByElement(ad["div"]), {
                                left: x + "px",
                                top: y + "px",
                            });
                            var cxy = this.getPosition(rr, this.getByElement(ad["div"]));
                            if (!this.isUndefined(ad["closeDiv"])) {
                                this.css(this.getByElement(ad["closeDiv"]), {
                                    left: cxy["x"] + "px",
                                    top: cxy["y"] + "px",
                                });
                            }
                        }
                    }
                }
            }
        },
        /*
			单独监听中间插入广告
		*/
        checkAdInsert: function (t) {
            if (this.adPlayerPlay) {
                return;
            }
            var adTime = this.advertisements["inserttime"];
            var adPlay = this.advertisements["insertPlay"];
            var duration = this.getMetaDate()["duration"];
            for (var i = adTime.length - 1; i > -1; i--) {
                if (t >= adTime[i] && t < duration - 2 && t > 1 && !adPlay[i]) {
                    //如果播放时间大于广告时间而该广告还没有播放，则开始播放
                    this.adI = 0;
                    this.adType = "insert";
                    this.adMuteInto();
                    this.adIsVideoTime = true;
                    this.adPlayStart = true;
                    this.adVideoPlay = false;
                    this.videoPause();
                    this.advertisementsTime();
                    this.advertisementsPlay();
                    this.adSkipButtonShow();
                    adPlay[i] = true;
                    for (var n = 0; n < i + 1; n++) {
                        adPlay[n] = true;
                    }
                    break;
                }
            }
        },
        /*格式化中间插入广告的播放时间*/
        formatInserttime: function (duration) {
            if (!this.isUndefined(this.advertisements["inserttime"])) {
                var arr = this.advertisements["inserttime"];
                var newArr = [];
                for (var i = 0; i < arr.length; i++) {
                    if (arr[i].toString().substr(-1) == "%") {
                        newArr.push(parseInt(duration * parseInt(arr[i]) * 0.01));
                    } else {
                        newArr.push(parseInt(arr[i]));
                    }
                }
                this.advertisements["inserttime"] = newArr;
            }
        },
        /*获取当前的广告*/
        getNowAdvertisements: function () {
            if (this.adI == -1) {
                return {
                    file: "",
                    time: 0,
                    link: "",
                };
            }
            return this.advertisements[this.adType][this.adI];
        },
        /*根据元件尺寸和播放器尺寸调整大小*/
        adjustmentWH: function (w, h) {
            var width = this.PD.offsetWidth,
                height = this.PD.offsetHeight;
            var nw = 0,
                nh = 0;
            if (w >= width || h >= height) {
                if (width / w > height / h) {
                    nh = height - 20;
                    nw = (w * nh) / h;
                } else {
                    nw = width - 20;
                    nh = (h * nw) / w;
                }
            } else {
                nw = w;
                nh = h;
            }
            return {
                width: nw,
                height: nh,
            };
        },
        /*单独请求一次地址，但不处理返回的数据*/
        ajaxSuccessNull: function (url) {
            if (!this.isUndefined(url)) {
                var ajaxObj = {
                    url: url,
                    success: function (data) {
                    },
                };
                this.ajax(ajaxObj);
            }
        },
        /*
			内部函数
			运行指定函数
		*/
        runFunction: function (s) {
            try {
                var arr = s.split("->");
                if (arr.length == 2) {
                    switch (arr[0]) {
                        case "javaScript":
                            if (arr[1].substr(0, 11) != "[flashvars]") {
                                eval(arr[1] + "()");
                            } else {
                                eval(this.vars[arr[1].substr(11)] + "()");
                            }
                            break;
                        case "actionScript":
                            eval("this." + arr[1] + "()");
                            break;
                    }
                }
                this.sendJS("clickEvent", s);
            } catch (event) {
            }
        },
        /*
			内部函数
			使用画布附加视频
		*/
        sendVCanvas: function () {
            if (this.timerVCanvas == null) {
                this.css(this.V, "display", "none");
                this.css(this.MD, "display", "block");
                var thisTemp = this;
                var videoCanvas = function () {
                    if (thisTemp.MDCX.width != thisTemp.MD.offsetWidth) {
                        thisTemp.MDC.width = thisTemp.MD.offsetWidth;
                    }
                    if (thisTemp.MDCX.height != thisTemp.MD.offsetHeight) {
                        thisTemp.MDC.height = thisTemp.MD.offsetHeight;
                    }
                    thisTemp.MDCX.clearRect(
                        0,
                        0,
                        thisTemp.MDCX.width,
                        thisTemp.MDCX.height,
                    );
                    var coor = thisTemp.getProportionCoor(
                        thisTemp.PD.offsetWidth,
                        thisTemp.PD.offsetHeight,
                        thisTemp.V.videoWidth,
                        thisTemp.V.videoHeight,
                    );
                    thisTemp.MDCX.drawImage(
                        thisTemp.V,
                        0,
                        0,
                        thisTemp.V.videoWidth,
                        thisTemp.V.videoHeight,
                        coor["x"],
                        coor["y"],
                        coor["width"],
                        coor["height"],
                    );
                };
                this.timerVCanvas = new this.timer(0, videoCanvas);
            }
        },
        /*
			内部函数
			监听暂停
		*/
        pauseHandler: function () {
            var thisTemp = this;
            this.playShow(false);
            if (this.animatePauseArray.length > 0) {
                this.animatePause("pause");
            }
            if (
                this.playerType == "html5video" &&
                this.V != null &&
                this.ckConfig["config"]["videoDrawImage"]
            ) {
                this.stopVCanvas();
            }
            if (
                !this.isUndefined(this.advertisements["pause"]) &&
                !this.adPlayStart &&
                !this.adPauseShow
            ) {
                //如果存在暂停广告
                setTimeout(function () {
                    if (
                        !thisTemp.isUndefined(thisTemp.advertisements["pause"]) &&
                        !thisTemp.adPlayStart &&
                        !thisTemp.adPauseShow &&
                        thisTemp.time > 1
                    ) {
                        //如果存在暂停广告
                        thisTemp.adPausePlayer();
                    }
                }, 300);
            }
        },
        /*
			内部函数
			停止画布
		*/
        stopVCanvas: function () {
            if (this.timerVCanvas != null) {
                this.css(this.V, "display", "block");
                this.css(this.MD, "display", "none");
                if (this.timerVCanvas.runing) {
                    this.timerVCanvas.stop();
                }
                this.timerVCanvas = null;
            }
        },
        /*
			内部函数
			根据当前播放还是暂停确认图标显示
		*/
        playShow: function (b) {
            if (!this.conBarShow) {
                return;
            }
            if (b) {
                this.css(this.CB["play"], "display", "none");
                this.css(this.CB["pauseCenter"], "display", "none");
                this.css(this.CB["pause"], "display", "block");
            } else {
                this.css(this.CB["play"], "display", "block");
                if (this.css(this.CB["errorText"], "display") == "none") {
                    if (!this.adPlayerPlay) {
                        this.css(this.CB["pauseCenter"], "display", "block");
                    }
                } else {
                    this.css(this.CB["pauseCenter"], "display", "none");
                }
                this.css(this.CB["pause"], "display", "none");
            }
        },
        /*
			内部函数
			监听seek结束
		*/
        seekedHandler: function () {
            this.resetTrack();
            this.isTimeButtonMove = true;
            if (this.V.paused) {
                if (this.hlsAutoPlay) {
                    this.videoPlay();
                } else {
                    this.hlsAutoPlay = true;
                }
            }
        },
        /*
			内部函数
			监听播放结束
		*/
        endedHandler: function () {
            this.sendJS("ended");
            if (this.adPlayerPlay) {
                this.adI++;
                this.advertisementsPlay();
                return;
            }
            if (!this.endAdPlay && !this.isUndefined(this.advertisements["end"])) {
                this.endAdPlay = true;
                this.adI = 0;
                this.adType = "end";
                this.adMuteInto();
                this.adIsVideoTime = true;
                this.adPlayStart = true;
                this.adVideoPlay = false;
                this.videoPause();
                this.advertisementsTime();
                this.advertisementsPlay();
                this.adSkipButtonShow();
                this.adReset = true;
                return;
            }
            this.endedAdReset();
            if (this.vars["loop"]) {
                this.videoSeek(0);
            }
        },
        /*
			重置结束后相关的设置
		*/
        endedAdReset: function () {
            var arr = [];
            var i = 0;
            if (!this.isUndefined(this.advertisements["insertPlay"])) {
                arr = this.advertisements["insertPlay"];
                for (i = 0; i < arr.length; i++) {
                    this.advertisements["insertPlay"][i] = false;
                }
            }
            if (!this.isUndefined(this.advertisements["otherPlay"])) {
                arr = this.advertisements["otherPlay"];
                for (i = 0; i < arr.length; i++) {
                    this.advertisements["otherPlay"][i] = false;
                }
            }
            //this.endAdPlay=false;
        },
        /*
			内部函数
			监听音量改变
		*/
        volumechangeHandler: function () {
            if (!this.conBarShow) {
                return;
            }
            if (
                (this.ckConfig["config"]["mobileVolumeBarShow"] || !this.isMobile()) &&
                this.css(this.CB["volume"], "display") != "none"
            ) {
                try {
                    var volume = this.volume || this.V.volume;
                    if (volume > 0) {
                        this.css(this.CB["mute"], "display", "block");
                        this.css(this.CB["escMute"], "display", "none");
                    } else {
                        this.css(this.CB["mute"], "display", "none");
                        this.css(this.CB["escMute"], "display", "block");
                    }
                } catch (event) {
                }
            }
        },
        /*
			内部函数
			监听播放时间调节进度条
		*/
        timeUpdateHandler: function () {
            var duration = 0;
            if (this.playerType == "html5video") {
                try {
                    duration = this.V.duration;
                } catch (event) {
                }
            }
            if (isNaN(duration) || parseInt(duration) < 0.2) {
                duration = this.vars["duration"];
            }
            if (this.vars["forceduration"] > 0) {
                duration = this.vars["forceduration"];
            }
            if (duration > 0) {
                this.time = this.V.currentTime;
                this.timeTextHandler();
                this.trackShowHandler();
                if (this.isTimeButtonMove) {
                    this.timeProgress(this.time, duration);
                }
            }
        },
        /*
			内部函数
			改变控制栏坐标
		*/
        controlBar: function () {
            //控制栏背景
            var cb = this.ckStyle["controlBar"];
            var cssObjTemp = {
                align: cb["align"],
                vAlign: cb["vAlign"],
                width: cb["width"],
                height: cb["height"],
                offsetX: cb["offsetX"],
                offsetY: cb["offsetY"],
            };
            var bgCss = {
                backgroundColor: cb["background"]["backgroundColor"],
                backgroundImg: cb["background"]["backgroundImg"],
                alpha: cb["background"]["alpha"],
            };
            var cssTemp = this.getEleCss(this.objectAssign(cssObjTemp, bgCss), {
                zIndex: 888,
            });
            this.css(this.CB["controlBarBg"], cssTemp);
            //控制栏容器
            cssTemp = this.getEleCss(cssObjTemp, {zIndex: 889});
            this.css(this.CB["controlBar"], cssTemp);
        },
        /*
			内部函数
			按时间改变进度条
		*/
        timeProgress: function (time, duration) {
            if (!this.conBarShow) {
                return;
            }
            var timeProgressBgW = this.CB["timeProgressBg"].offsetWidth;
            var timeBOW = parseInt(
                (time * timeProgressBgW) / duration -
                this.CB["timeButton"].offsetWidth * 0.5,
            );
            if (timeBOW > timeProgressBgW - this.CB["timeButton"].offsetWidth) {
                timeBOW = timeProgressBgW - this.CB["timeButton"].offsetWidth;
            }
            if (timeBOW < 0) {
                timeBOW = 0;
            }
            this.css(this.CB["timeProgress"], "width", timeBOW + "px");
            this.css(this.CB["timeButton"], "left", parseInt(timeBOW) + "px");
        },
        /*
			内部函数
			监听播放时间改变时间显示文本框
		*/
        timeTextHandler: function () {
            //显示时间/总时间
            if (!this.conBarShow) {
                return;
            }
            var duration = this.V.duration;
            var time = this.V.currentTime;
            if (isNaN(duration) || parseInt(duration) < 0.2) {
                duration = this.vars["duration"];
            }
            if (this.vars["forceduration"] > 0) {
                duration = this.vars["forceduration"];
            }
            this.CB["timeText"].innerHTML = this.formatTime(
                time,
                duration,
                this.ckLanguage["vod"],
            );
        },
        /*
			内部函数
			监听是否是缓冲状态
		*/
        bufferEdHandler: function () {
            if (!this.conBarShow || this.playerType == "flashplayer") {
                return;
            }
            var thisTemp = this;
            var clearTimerBuffer = function () {
                if (thisTemp.timerBuffer != null) {
                    if (thisTemp.timerBuffer.runing) {
                        thisTemp.sendJS("buffer", 100);
                        thisTemp.timerBuffer.stop();
                    }
                    thisTemp.timerBuffer = null;
                }
            };
            clearTimerBuffer();
            var bufferFun = function () {
                if (
                    !thisTemp.isUndefined(thisTemp.V) &&
                    thisTemp.V.buffered.length > 0
                ) {
                    var duration = thisTemp.V.duration;
                    var len = thisTemp.V.buffered.length;
                    var bufferStart = thisTemp.V.buffered.start(len - 1);
                    var bufferEnd = thisTemp.V.buffered.end(len - 1);
                    var loadTime = bufferStart + bufferEnd;
                    var loadProgressBgW = thisTemp.CB["timeProgressBg"].offsetWidth;
                    var timeButtonW = thisTemp.CB["timeButton"].offsetWidth;
                    var loadW = parseInt(
                        (loadTime * loadProgressBgW) / duration + timeButtonW,
                    );
                    if (loadW >= loadProgressBgW) {
                        loadW = loadProgressBgW;
                        clearTimerBuffer();
                    }
                    thisTemp.changeLoad(loadTime);
                }
            };
            this.timerBuffer = new this.timer(200, bufferFun);
        },
        /*
			内部函数
			单独计算加载进度
		*/
        changeLoad: function (loadTime) {
            if (this.V == null) {
                return;
            }
            if (!this.conBarShow) {
                return;
            }
            var loadProgressBgW = this.CB["timeProgressBg"].offsetWidth;
            var timeButtonW = this.CB["timeButton"].offsetWidth;
            var duration = this.V.duration;
            if (isNaN(duration) || parseInt(duration) < 0.2) {
                duration = this.vars["duration"];
            }
            if (this.vars["forceduration"] > 0) {
                duration = this.vars["forceduration"];
            }
            if (this.isUndefined(loadTime)) {
                loadTime = this.loadTime;
            } else {
                this.loadTime = loadTime;
            }
            var loadW = parseInt(
                (loadTime * loadProgressBgW) / duration + timeButtonW,
            );
            this.css(this.CB["loadProgress"], "width", loadW + "px");
            this.sendJS("loadTime", loadTime);
            this.loadTimeTemp = loadTime;
        },
        /*
			内部函数
			判断是否是直播
		*/
        judgeIsLive: function () {
            var thisTemp = this;
            if (this.timerError != null) {
                if (this.timerError.runing) {
                    this.timerError.stop();
                }
                this.timerError = null;
            }
            this.error = false;
            if (this.conBarShow) {
                this.css(this.CB["errorText"], "display", "none");
            }
            var timeupdate = function (event) {
                thisTemp.timeUpdateHandler();
            };
            if (!this.vars["live"]) {
                if (this.V != null && this.playerType == "html5video") {
                    this.addListenerInside("timeupdate", timeupdate);
                    thisTemp.timeTextHandler();
                    thisTemp.prompt(); //添加提示点
                    setTimeout(function () {
                        thisTemp.bufferEdHandler();
                    }, 200);
                }
            } else {
                this.removeListenerInside("timeupdate", timeupdate);
                if (this.timerTime != null) {
                    window.clearInterval(this.timerTime);
                    timerTime = null;
                }
                if (this.timerTime != null) {
                    if (this.timerTime.runing) {
                        this.timerTime.stop();
                    }
                    this.timerTime = null;
                }
                var timeFun = function () {
                    if (thisTemp.V != null && !thisTemp.V.paused && thisTemp.conBarShow) {
                        thisTemp.CB["timeText"].innerHTML = thisTemp.formatTime(
                            0,
                            0,
                            thisTemp.ckLanguage["live"],
                        ); //时间显示框默认显示内容
                    }
                };
                this.timerTime = new this.timer(1000, timeFun);
                //timerTime.start();
            }
            this.definition();
        },
        /*
			内部函数
			加载字幕
		*/
        loadTrack: function (def) {
            if (
                this.playerType == "flashplayer" ||
                this.vars["flashplayer"] == true
            ) {
                return;
            }
            if (this.isUndefined(def)) {
                def = -1;
            }
            var track = this.vars["cktrack"];
            var loadTrackUrl = "";
            var type = this.varType(track);
            var thisTemp = this;
            if (type == "array") {
                if (def == -1) {
                    var index = 0;
                    var indexN = 0;
                    for (var i = 0; i < track.length; i++) {
                        var li = track[i];
                        if (li.length == 3 && li[2] > indexN) {
                            indexN = li[2];
                            index = i;
                        }
                    }
                } else {
                    index = def;
                }
                loadTrackUrl = track[index][0];
            } else {
                loadTrackUrl = track;
            }
            var obj = {
                method: "get",
                dataType: "text",
                url: loadTrackUrl,
                charset: "utf-8",
                success: function (data) {
                    if (data) {
                        thisTemp.track = thisTemp.parseSrtSubtitles(data);
                        thisTemp.trackIndex = 0;
                        thisTemp.nowTrackShow = {
                            sn: "",
                        };
                    }
                },
            };
            this.ajax(obj);
        },
        /*
			内部函数
			重置字幕
		*/
        resetTrack: function () {
            this.trackIndex = 0;
            this.nowTrackShow = {
                sn: "",
            };
        },
        /*
			内部函数
			根据时间改变读取显示字幕
		*/
        trackShowHandler: function () {
            if (!this.conBarShow || this.adPlayerPlay) {
                return;
            }
            if (this.track.length < 1) {
                return;
            }
            if (this.trackIndex >= this.track.length) {
                this.trackIndex = 0;
            }
            var nowTrack = this.track[this.trackIndex]; //当前编号对应的字幕内容
            /*
				this.nowTrackShow=当前显示在界面上的内容
				如果当前时间正好在nowTrack时间内，则需要判断
			*/
            if (
                this.time >= nowTrack["startTime"] &&
                this.time <= nowTrack["endTime"]
            ) {
                /*
				 	如果当前显示的内容不等于当前需要显示的内容时，则需要显示正确的内容
				*/
                var nowShow = this.nowTrackShow;
                if (nowShow["sn"] != nowTrack["sn"]) {
                    this.trackHide();
                    this.trackShow(nowTrack);
                    this.nowTrackTemp = nowTrack;
                }
            } else {
                /*
				  如果当前播放时间不在当前编号字幕内，则需要先清空当前的字幕内容，再显示新的字幕内容
				*/
                this.trackHide();
                this.checkTrack();
            }
        },
        trackShowAgain: function () {
            this.trackHide();
            this.trackShow(this.nowTrackTemp);
        },
        /*
			内部函数
			显示字幕内容
		*/
        trackShow: function (track) {
            this.nowTrackShow = track;
            var arr = track["content"];
            for (var i = 0; i < arr.length; i++) {
                var obj = {
                    list: [
                        {
                            type: "text",
                            text: arr[i],
                            color: this.ckStyle["cktrack"]["color"],
                            size: this.ckStyle["cktrack"]["size"],
                            fontFamily: this.ckStyle["cktrack"]["font"],
                            lineHeight: this.ckStyle["cktrack"]["leading"] + "px",
                        },
                    ],
                    position: [
                        1,
                        2,
                        null,
                        -(arr.length - i) * this.ckStyle["cktrack"]["leading"] -
                        this.ckStyle["cktrack"]["marginBottom"],
                    ],
                };
                var ele = this.addElement(obj);
                this.trackElement.push(ele);
            }
        },
        /*
			内部函数
			隐藏字幕内容
		*/
        trackHide: function () {
            for (var i = 0; i < this.trackElement.length; i++) {
                this.deleteElement(this.trackElement[i]);
            }
            this.trackElement = [];
        },
        /*
			内部函数
			重新计算字幕的编号
		*/
        checkTrack: function () {
            var num = this.trackIndex;
            var arr = this.track;
            var i = 0;
            for (i = num; i < arr.length; i++) {
                if (
                    this.time >= arr[i]["startTime"] &&
                    this.time <= arr[i]["endTime"]
                ) {
                    this.trackIndex = i;
                    break;
                }
            }
        },
        /*
		-----------------------------------------------------------------------------接口函数开始
			接口函数
			在播放和暂停之间切换
		*/
        playOrPause: function () {
            if (!this.loaded) {
                return;
            }
            if (this.V == null) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.playOrPause();
                return;
            }
            if (this.V.paused) {
                this.videoPlay();
            } else {
                this.videoPause();
            }
        },
        /*
			接口函数
			播放动作
		*/
        videoPlay: function () {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.videoPlay();
                return;
            }
            if (this.adPlayerPlay) {
                this.eliminateAd(); //清除广告
                return;
            }
            try {
                if (this.V.currentSrc) {
                    this.V.play();
                }
            } catch (event) {
            }
        },
        /*
			接口函数
			暂停动作
		*/
        videoPause: function () {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.videoPause();
                return;
            }
            try {
                this.V.pause();
            } catch (event) {
            }
        },
        /*
			接口函数
			跳转时间动作
		*/
        videoSeek: function (time) {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.videoSeek(time);
                return;
            }
            var duration =
                this.V.duration > 0.2
                    ? this.V.duration
                    : this.getMetaDate()["duration"];
            if (duration > 0 && time > duration) {
                if (this.vars["forceduration"] > 0) {
                    time = 0;
                    this.sendJS("ended");
                } else {
                    time = duration - 0.1;
                }
            }
            if (time >= 0) {
                this.V.currentTime = time;
                this.sendJS("seekTime", time);
            }
        },
        /*
			接口函数
			调节音量/获取音量
		*/
        changeVolume: function (vol, bg, button) {
            if (this.loaded) {
                if (this.playerType == "flashplayer") {
                    this.V.changeVolume(vol);
                    return;
                }
            }
            if (isNaN(vol) || this.isUndefined(vol)) {
                vol = 0;
            }
            if (!this.loaded) {
                this.vars["volume"] = vol;
            }
            if (!this.html5Video) {
                this.V.changeVolume(vol);
                return;
            }
            try {
                if (this.isUndefined(bg)) {
                    bg = true;
                }
            } catch (e) {
            }
            try {
                if (this.isUndefined(button)) {
                    button = true;
                }
            } catch (e) {
            }
            if (!vol) {
                vol = 0;
            }
            if (vol < 0) {
                vol = 0;
            }
            if (vol > 1) {
                vol = 1;
            }
            try {
                this.V.volume = vol;
            } catch (error) {
            }
            this.volume = vol;
            if (bg && this.conBarShow) {
                var bgW = vol * this.CB["volumeBg"].offsetWidth;
                if (bgW < 0) {
                    bgW = 0;
                }
                if (bgW > this.CB["volumeBg"].offsetWidth) {
                    bgW = this.CB["volumeBg"].offsetWidth;
                }
                this.css(this.CB["volumeUp"], "width", bgW + "px");
            }

            if (button && this.conBarShow) {
                var buLeft = parseInt(
                    this.CB["volumeUp"].offsetWidth -
                    this.CB["volumeBO"].offsetWidth * 0.5,
                );
                if (
                    buLeft >
                    this.CB["volumeBg"].offsetWidth - this.CB["volumeBO"].offsetWidth
                ) {
                    buLeft =
                        this.CB["volumeBg"].offsetWidth - this.CB["volumeBO"].offsetWidth;
                }
                if (buLeft < 0) {
                    buLeft = 0;
                }
                this.css(this.CB["volumeBO"], "left", buLeft + "px");
            }
        },
        /*
			接口函数
			静音
		*/
        videoMute: function () {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.videoMute();
                return;
            }
            this.volumeTemp = this.V
                ? this.V.volume > 0
                    ? this.V.volume
                    : this.vars["volume"]
                : this.vars["volume"];
            this.changeVolume(0);
        },
        /*
			接口函数
			取消静音
		*/
        videoEscMute: function () {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.videoEscMute();
                return;
            }
            this.changeVolume(
                this.volumeTemp > 0 ? this.volumeTemp : this.vars["volume"],
            );
        },
        /*
			接口函数
			视频广告静音
		*/
        adMute: function () {
            if (!this.loaded) {
                return;
            }
            this.changeVolume(0);
            this.adVideoMute = true;
            this.css(this.CB["adEscMute"], "display", "block");
            this.css(this.CB["adMute"], "display", "none");
        },
        /*
			接口函数
			视频广告取消静音
		*/
        escAdMute: function () {
            if (!this.loaded) {
                return;
            }
            var v = this.ckStyle["advertisement"]["videoVolume"];
            this.changeVolume(v);
            this.adMuteInto();
        },
        /*
		 	初始化广告的音量按钮
		*/
        adMuteInto: function () {
            this.adVideoMute = false;
            this.css(this.CB["adEscMute"], "display", "none");
            this.css(this.CB["adMute"], "display", "block");
        },
        /*
			接口函数
			快退
		*/
        fastBack: function () {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.fastBack();
                return;
            }
            var time = this.time - this.ckConfig["config"]["timeJump"];
            if (time < 0) {
                time = 0;
            }
            this.videoSeek(time);
        },
        /*
			接口函数
			快进
		*/
        fastNext: function () {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.fastNext();
                return;
            }
            var time = this.time + this.ckConfig["config"]["timeJump"];
            if (time > this.V.duration) {
                time = this.V.duration;
            }
            this.videoSeek(time);
        },
        /*
			接口函数
			获取当前播放的地址
		*/
        getCurrentSrc: function () {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                return this.V.getCurrentSrc();
            }
            return this.V.currentSrc;
        },
        /*
			内置函数
			全屏/退出全屏动作，该动作只能是用户操作才可以触发，比如用户点击按钮触发该事件
		*/
        switchFull: function () {
            if (this.full) {
                this.quitFullScreen();
            } else {
                this.fullScreen();
            }
        },
        /*
			内置函数
			全屏动作，该动作只能是用户操作才可以触发，比如用户点击按钮触发该事件
		*/
        fullScreen: function () {
            if (this.html5Video && this.playerType == "html5video") {
                var element = this.PD;
                if (element.requestFullscreen) {
                    element.requestFullscreen();
                } else if (element.mozRequestFullScreen) {
                    element.mozRequestFullScreen();
                } else if (element.webkitRequestFullscreen) {
                    element.webkitRequestFullscreen();
                } else if (element.msRequestFullscreen) {
                    element.msRequestFullscreen();
                } else if (element.oRequestFullscreen) {
                    element.oRequestFullscreen();
                }
                this.judgeFullScreen();
            } else {
                //this.V.fullScreen();
            }
        },
        /*
			接口函数
			退出全屏动作
		*/
        quitFullScreen: function () {
            if (this.html5Video && this.playerType == "html5video") {
                if (document.exitFullscreen) {
                    document.exitFullscreen();
                } else if (document.msExitFullscreen) {
                    document.msExitFullscreen();
                } else if (document.mozCancelFullScreen) {
                    document.mozCancelFullScreen();
                } else if (document.oRequestFullscreen) {
                    document.oCancelFullScreen();
                } else if (document.requestFullscreen) {
                    document.requestFullscreen();
                } else if (document.webkitExitFullscreen) {
                    document.webkitExitFullscreen();
                } else {
                    this.css(document.documentElement, "cssText", "");
                    this.css(document.document.body, "cssText", "");
                    this.css(this.PD, "cssText", "");
                }
                this.judgeFullScreen();
            }
        },
        /*
		 下面列出只有flashplayer里支持的
		 */
        videoRotation: function (n) {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.videoRotation(n);
                return;
            }
            if (this.isUndefined(n)) {
                n = 0;
            }
            var tf = this.css(this.V, "transform");
            if (this.isUndefined(tf) && !tf) {
                tf = "rotate(0deg)";
            }
            var reg = tf.match(/rotate\([^)]+\)/);
            reg = reg ? reg[0].replace("rotate(", "").replace("deg)", "") : "";
            if (reg == "") {
                reg = 0;
            } else {
                reg = parseInt(reg);
            }
            if (n == -1) {
                reg -= 90;
            } else if (n == 1) {
                reg += 90;
            } else {
                if (
                    n != 90 &&
                    n != 180 &&
                    n != 270 &&
                    n != -90 &&
                    n != -180 &&
                    n != -270
                ) {
                    reg = 0;
                } else {
                    reg = n;
                }
            }
            n = reg;
            var y90 = n % 90,
                y180 = n % 180,
                y270 = n % 270;
            var ys = false;
            if (y90 == 0 && y180 == 90 && y270 == 90) {
                ys = true;
            }
            if (y90 == 0 && y180 == 90 && y270 == 0) {
                ys = true;
            }
            if (y90 == -0 && y180 == -90 && y270 == -90) {
                ys = true;
            }
            if (y90 == -0 && y180 == -90 && y270 == -0) {
                ys = true;
            }
            tf =
                tf.replace(/rotate\([^)]+\)/, "").replace(/scale\([^)]+\)/, "") +
                " rotate(" +
                n +
                "deg)";
            var cdW = this.CD.offsetWidth,
                cdH = this.CD.offsetHeight,
                vW = this.V.videoWidth,
                vH = this.V.videoHeight;
            if (vW > 0 && vH > 0) {
                if (ys) {
                    if (cdW / cdH > vH / vW) {
                        nH = cdH;
                        nW = (vH * nH) / vW;
                    } else {
                        nW = cdW;
                        nH = (vW * nW) / vH;
                    }
                    this.css(this.V, "transform", "rotate(0deg)");
                    this.css(
                        this.V,
                        "transform",
                        "scale(" + nH / cdW + "," + nW / cdH + ")" + tf,
                    );
                } else {
                    this.css(this.V, "transform", tf);
                }
            } else {
                this.css(this.V, "transform", tf);
            }
            return;
        },
        videoBrightness: function (n) {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.videoBrightness(n);
                return;
            }
        },
        videoContrast: function (n) {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.videoContrast(n);
                return;
            }
        },
        videoSaturation: function (n) {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.videoSaturation(n);
                return;
            }
        },
        videoHue: function (n) {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.videoHue(n);
                return;
            }
        },
        videoZoom: function (n) {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.videoZoom(n);
                return;
            }
            if (this.isUndefined(n)) {
                n = 1;
            }
            if (n < 0) {
                n = 0;
            }
            if (n > 2) {
                n = 2;
            }
            var tf = this.css(this.V, "transform");
            tf = tf.replace(/scale\([^)]+\)/, "") + " scale(" + n + ")";
            this.videoScale = n;
            this.css(this.V, "transform", tf);
            return;
        },
        videoProportion: function (w, h) {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.videoProportion(w, h);
                return;
            }
        },
        adPlay: function () {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.adPlay();
                return;
            }
            if (this.adPlayerPlay) {
                this.adIsPause = false;
                var ad = this.getNowAdvertisements();
                var type = ad["type"];
                if (this.isStrImage(type)) {
                    this.adCountDown();
                } else {
                    this.V.play();
                }
            }
        },
        adPause: function () {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.adPause();
                return;
            }
            if (this.adPlayerPlay) {
                this.adIsPause = true;
                var ad = this.getNowAdvertisements();
                var type = ad["type"];
                if (
                    type != "jpg" &&
                    type != "jpeg" &&
                    type != "png" &&
                    type != "svg" &&
                    type != "gif"
                ) {
                    this.videoPause();
                }
            }
        },
        videoError: function (n) {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.videoError(n);
                return;
            }
        },
        changeConfig: function () {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                var args = Array.prototype.slice.call(arguments);
                switch (args.length) {
                    case 1:
                        this.V.changeConfig(args[0]);
                        break;
                    case 2:
                        this.V.changeConfig(args[0], args[1]);
                        break;
                    case 3:
                        this.V.changeConfig(args[0], args[1], args[2]);
                        break;
                    case 4:
                        this.V.changeConfig(args[0], args[1], args[2], args[3]);
                        break;
                    case 5:
                        this.V.changeConfig(args[0], args[1], args[2], args[3], args[4]);
                        break;
                    case 6:
                        this.V.changeConfig(
                            args[0],
                            args[1],
                            args[2],
                            args[3],
                            args[4],
                            args[5],
                        );
                        break;
                    case 7:
                        this.V.changeConfig(
                            args[0],
                            args[1],
                            args[2],
                            args[3],
                            args[4],
                            args[5],
                            args[6],
                        );
                        break;
                    case 8:
                        this.V.changeConfig(
                            args[0],
                            args[1],
                            args[2],
                            args[3],
                            args[4],
                            args[5],
                            args[6],
                            args[7],
                        );
                        break;
                    case 8:
                        this.V.changeConfig(
                            args[0],
                            args[1],
                            args[2],
                            args[3],
                            args[4],
                            args[5],
                            args[6],
                            args[7],
                            args[8],
                        );
                        break;
                }
                return;
            }
            var obj = this.ckConfig;
            var arg = arguments;
            for (var i = 0; i < arg.length - 1; i++) {
                if (obj.hasOwnProperty(arg[i])) {
                    obj = obj[arg[i]];
                } else {
                    return;
                }
            }
            var val = arg[arg.length - 1];
            switch (arg.length) {
                case 2:
                    this.ckConfig[arg[0]] = val;
                    break;
                case 3:
                    this.ckConfig[arg[0]][arg[1]] = val;
                    break;
                case 4:
                    this.ckConfig[arg[0]][arg[1]][arg[2]] = val;
                    break;
                case 5:
                    this.ckConfig[arg[0]][arg[1]][arg[2]][arg[3]] = val;
                    break;
                case 6:
                    this.ckConfig[arg[0]][arg[1]][arg[2]][arg[3]][arg[4]] = val;
                    break;
                case 7:
                    this.ckConfig[arg[0]][arg[1]][arg[2]][arg[3]][arg[4]][arg[5]] = val;
                    break;
                case 8:
                    this.ckConfig[arg[0]][arg[1]][arg[2]][arg[3]][arg[4]][arg[5]][
                        arg[6]
                        ] = val;
                    break;
                case 9:
                    this.ckConfig[arg[0]][arg[1]][arg[2]][arg[3]][arg[4]][arg[5]][arg[6]][
                        arg[7]
                        ] = val;
                    break;
                case 10:
                    this.ckConfig[arg[0]][arg[1]][arg[2]][arg[3]][arg[4]][arg[5]][arg[6]][
                        arg[7]
                        ][arg[8]] = val;
                    break;
                default:
                    break;
            }
            this.sendJS("configChange", this.ckConfig);
        },
        custom: function () {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.custom(arguments);
                return;
            }
            if (this.isUndefined(arguments)) {
                return;
            }
            var type = "",
                name = "",
                display = "";
            if (arguments.length == 4) {
                //控制栏
                type = "controlBar-" + arguments[1];
                name = arguments[2];
                display = arguments[3] ? "block" : "none";
            } else if (arguments.length == 3) {
                //播放器
                type = "player-" + arguments[0];
                name = arguments[1];
                display = arguments[2] ? "block" : "none";
            } else {
                return;
            }
            for (var k in this.customeElement) {
                var obj = this.customeElement[k];
                if (obj["type"] == type && obj["name"] == name) {
                    this.css(obj["ele"], "display", display);
                }
            }
        },
        getConfig: function () {
            if (!this.loaded) {
                return null;
            }
            if (this.playerType == "flashplayer") {
                return this.V.getConfig(arguments);
            } else {
                var temp = this.ckConfig;
                for (var index in arguments) {
                    try {
                        temp = temp[arguments[index]];
                    } catch (error) {
                        temp = null;
                    }
                }
                return temp;
            }
        },
        openUrl: function (n) {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.openUrl(n);
                return;
            }
        },
        /*
			接口函数
			清除视频
		*/
        videoClear: function () {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.videoClear();
                return;
            }
            this.V.innerHTML = "";
            this.V.src = "";
        },
        /*
			接口函数
			向播放器传递新的视频地址
		*/
        newVideo: function (c) {
            if (this.playerType == "flashplayer") {
                this.V.newVideo(c);
                return;
            } else {
                this.embed(c);
            }
        },
        /*
			接口函数
			截图
		*/
        screenshot: function (obj, save, name) {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                try {
                    this.V.screenshot(obj, save, name);
                } catch (error) {
                    this.log(error);
                }
                return;
            }
            if (obj == "video") {
                var newCanvas = document.createElement("canvas");
                newCanvas.width = this.V.videoWidth;
                newCanvas.height = this.V.videoHeight;
                newCanvas
                    .getContext("2d")
                    .drawImage(this.V, 0, 0, this.V.videoWidth, this.V.videoHeight);
                try {
                    var base64 = newCanvas.toDataURL("image/jpeg");
                    this.sendJS("screenshot", {
                        object: obj,
                        save: save,
                        name: name,
                        base64: base64,
                    });
                } catch (error) {
                    this.log(error);
                }
            }
        },
        /*
			接口函数
			改变播放器尺寸
		*/
        changeSize: function (w, h) {
            if (this.isUndefined(w)) {
                w = 0;
            }
            if (this.isUndefined(h)) {
                h = 0;
            }
            if (w > 0) {
                this.css(this.CD, "width", w + "px");
            }
            if (h > 0) {
                this.css(this.CD, "height", h + "px");
            }
            if (this.html5Video) {
                this.playerResize();
            }
        },
        /*
			重置播放器界面
		*/
        playerResize: function () {
            this.controlBar(); //控制栏按钮
            this.elementCoordinate();
            this.carbarButton();
            this.customCoor(); //自定义元件的位置重置
            this.timeProgressDefault(); //进度条默认样式
            this.videoCss(); //计算video的宽高和位置
            this.timeUpdateHandler(); //修改进度条样式
            this.changeElementCoor(); //修改新加元件的坐标
            this.changePrompt(); //重置提示点
            this.advertisementStyle(); //广告控制样式
            this.adPauseCoor();
            this.adOtherCoor();
            this.changeLoad();
            this.sendJS("resize");
        },
        /*
			接口函数
			改变视频播放速度
		*/
        changePlaybackRate: function (n) {
            if (this.html5Video) {
                var arr = this.playbackRateArr;
                n = parseInt(n);
                if (n < arr.length) {
                    this.newPlaybackrate(arr[n][1]);
                }
            }
        },
        /*
			内部函数
			注册控制控制栏显示与隐藏函数
		*/
        changeControlBarShow: function (show) {
            if (!this.loaded) {
                return;
            }
            if (this.playerType == "flashplayer") {
                this.V.changeControlBarShow(show);
                return;
            }
            if (show) {
                this.controlBarIsShow = true;
                this.controlBarHide(false);
            } else {
                this.controlBarIsShow = false;
                this.controlBarHide(true);
            }
        },
        /*
			-----------------------------------------------------------------------
			调用flashplayer
		*/
        embedSWF: function () {
            var vid = "ckplayer-" + this.randomString();
            var flashvars = this.getFlashVars();
            var param = this.getFlashplayerParam();
            var flashplayerUrl = "http://www.macromedia.com/go/getflashplayer";
            var html = "",
                src = this.ckplayerPath + "ckplayer.swf";
            id = 'id="' + vid + '" name="' + vid + '" ';
            html +=
                '<object pluginspage="' +
                flashplayerUrl +
                '" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"  codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=11,3,0,0" width="100%" height="100%" ' +
                id +
                ' align="middle" wmode="transparent">';
            html += param["v"];
            html += '<param name="movie" value="' + src + '">';
            html += '<param name="flashvars" value="' + flashvars + '">';
            html += '<param name="wmode" value="transparent">';
            html +=
                '<embed wmode="transparent" ' +
                param["w"] +
                ' src="' +
                src +
                '" flashvars="' +
                flashvars +
                '" width="100%" height="100%" ' +
                id +
                ' align="middle" type="application/x-shockwave-flash" pluginspage="' +
                flashplayerUrl +
                '" />';
            html += "</object>";
            this.PD.innerHTML = html;
            this.V = this.getObjectById(vid); //V：定义播放器对象全局变量
            this.playerType = "flashplayer";
        },
        /*
			判断浏览器是否支持flashplayer
		*/
        checkShockwaveFlash: function () {
            if (window.ActiveXObject) {
                try {
                    var s = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
                    if (s) {
                        return true;
                    }
                } catch (e) {
                }
            } else {
                try {
                    var s = navigator.plugins["Shockwave Flash"];
                    if (s) {
                        return true;
                    }
                } catch (e) {
                }
            }
            return false;
        },
        /*
			内置函数
			将vars对象转换成字符
		*/
        getFlashVars: function () {
            this.getVarsObject();
            var v = this.vars;
            var z = "";
            for (k in v) {
                if (k != "flashplayer" && k != "container" && v[k] != "") {
                    if (z != "") {
                        z += "&";
                    }
                    var vk = v[k];
                    if (vk == true) {
                        vk = 1;
                    }
                    if (vk == false) {
                        vk = 0;
                    }
                    z += k + "=" + vk;
                }
            }
            if (!v.hasOwnProperty("volume") || !v["volume"]) {
                if (z != "") {
                    z += "&";
                }
                z += "volume=0";
            }
            return z;
        },
        /*判断字符串是否是图片*/
        isStrImage: function (s) {
            if (s == "jpg" || s == "jpeg" || s == "png" || s == "svg" || s == "gif") {
                return true;
            }
            return false;
        },
        /*
			内置函数
			将vars格式化成flash能接受的对象。再由getFlashVars函数转化成字符串或由newVideo直接使用
		*/
        getVarsObject: function () {
            var v = this.vars;
            var f = "",
                d = "",
                w = ""; //f=视频地址，d=清晰度地址,w=权重，z=最终地址
            var arr = this.VA;
            var prompt = v["promptSpot"];
            var i = 0;
            var video = this.vars["video"];
            if (this.varType(video) == "array") {
                //对象或数组
                var arr = video;
                for (i = 0; i < arr.length; i++) {
                    var arr2 = arr[i];
                    if (arr2) {
                        if (f != "") {
                            f += this.ckConfig["config"]["split"];
                            d += ",";
                            w += ",";
                            v["type"] += this.ckConfig["config"]["split"];
                        }
                        f += encodeURIComponent(decodeURIComponent(arr2[0]));
                        d += arr2[2];
                        w += arr2[3];
                        v["type"] += arr2[1].replace("video/", "");
                    }
                }
            } else if (this.varType(video) == "object") {
                //对象或数组
                f = encodeURIComponent(decodeURIComponent(video["file"]));
                if (!this.isUndefined(video["type"])) {
                    v["type"] = video["type"];
                }
                d = "";
                w = "";
            } else {
                f = encodeURIComponent(decodeURIComponent(video));
            }
            if (v["preview"] != null) {
                v["previewscale"] = v["preview"]["scale"];
                v["preview"] = v["preview"]["file"].join(",");
            }
            if (prompt != null) {
                v["promptspot"] = "";
                v["promptspottime"] = "";
                for (i = 0; i < prompt.length; i++) {
                    if (v["promptspot"] != "") {
                        v["promptspot"] += ",";
                        v["promptspottime"] += ",";
                    }
                    v["promptspot"] += prompt[i]["words"];
                    v["promptspottime"] += prompt[i]["time"];
                }
            }
            if (f != "") {
                v["video"] = f;
                v["definition"] = d;
                v["weight"] = w;
            }
            if (!v["volume"]) {
                v["volume"] = 0;
            }
            var newV = {};

            for (var k in v) {
                if (v[k] != null) {
                    newV[k] = v[k];
                }
                if (k == "type") {
                    newV[k] = v[k].replace("video/m3u8", "m3u8");
                }
            }

            this.vars = newV;
        },
        /*
			内置函数
			将embedSWF里的param的对象进行转换
		*/
        getFlashplayerParam: function () {
            var w = "",
                v = "",
                o = {
                    allowScriptAccess: "always",
                    allowFullScreen: true,
                    quality: "high",
                    bgcolor: "#000",
                };
            for (var e in o) {
                w += e + '="' + o[e] + '" ';
                v += '<param name="' + e + '" value="' + o[e] + '" />';
            }
            w = w.replace("movie=", "src=");
            return {
                w: w,
                v: v,
            };
        },

        /*
			操作动作结束
			-----------------------------------------------------------------------

			接口函数
			获取元数据部分
		*/
        getMetaDate: function () {
            if (!this.loaded || this.V == null) {
                return false;
            }
            if (this.playerType == "html5video") {
                var duration = 0;
                try {
                    duration = !isNaN(this.V.duration) ? this.V.duration : 0;
                    if (isNaN(duration) || parseInt(duration) < 0.2) {
                        if (this.vars["duration"] > 0) {
                            duration = this.vars["duration"];
                        }
                    }
                    if (this.vars["forceduration"] > 0) {
                        duration = this.vars["forceduration"];
                    }
                } catch (event) {
                    this.log(event);
                }
                var data = {
                    duration: duration,
                    volume: this.V.volume,
                    playbackRate: this.V.playbackRate,
                    width: this.PD.offsetWidth || this.V.offsetWidth || this.V.width,
                    height: this.PD.offsetHeight || this.V.offsetHeight || this.V.height,
                    streamWidth: this.V.videoWidth,
                    streamHeight: this.V.videoHeight,
                    videoWidth: this.V.offsetWidth,
                    videoHeight: this.V.offsetHeight,
                    paused: this.V.paused,
                    loadTime: this.loadTimeTemp,
                };
                return data;
            } else {
                try {
                    return this.V.getMetaDate();
                } catch (event) {
                    this.log(event);
                }
            }
            return false;
        },
        /*
			接口函数
			取当前提供给播放器播放的视频列表
		*/
        getVideoUrl: function () {
            if (this.playerType == "flashplayer") {
                return this.V.getVideoUrl();
            }
            var arr = [];
            if (this.V.src) {
                arr.push(this.V.src);
            } else {
                var uArr = this.V.childNodes;
                for (var i = 0; i < uArr.length; i++) {
                    arr.push(uArr[i].src);
                }
            }
            return arr;
        },
        /*
			内置函数
			格式化函数
		*/
        clickEvent: function (call) {
            if (call == "none" || call == "" || call == null) {
                return {
                    type: "none",
                };
            }
            var callArr = call.split("->");
            var type = "",
                fun = "",
                link = "",
                target = "";
            if (callArr.length == 2) {
                var callM = callArr[0];
                var callE = callArr[1];
                if (!callE) {
                    return {
                        type: "none",
                    };
                }
                var val = "";
                var eArr = [];
                type = callM;
                switch (callM) {
                    case "actionScript":
                        //trace(THIS.hasOwnProperty(callE));
                        if (callE.indexOf("(") > -1) {
                            eArr = callE.split("(");
                            callE = eArr[0];
                            val = eArr[1].replace(")", "");
                        }
                        if (val == "") {
                            fun = "thisTemp." + callE + "()";
                        } else {
                            fun = "thisTemp." + callE + "(" + val + ")";
                        }
                        break;
                    case "javaScript":
                        if (callE.substr(0, 11) == "[flashvars]") {
                            callE = callE.substr(11);
                            if (this.vars.hasOwnProperty(callE)) {
                                callE = this.vars[callE];
                            } else {
                                break;
                            }
                        }
                        if (callE.indexOf("(") > -1) {
                            eArr = callE.split("(");
                            callE = eArr[0];
                            val = eArr[1].replace(")", "");
                        }
                        if (val == "") {
                            fun = callE + "()";
                        } else {
                            fun = callE + "(" + val + ")";
                        }
                        break;
                    case "link":
                        var callLink = (callE + ",").split(",");
                        if (callLink[0].substr(0, 11) == "[flashvars]") {
                            var fl = callLink[0].replace("[flashvars]", "");
                            if (this.vars.hasOwnProperty(fl)) {
                                callLink[0] = this.vars[fl];
                            } else {
                                break;
                            }
                        }
                        if (!callLink[1]) {
                            callLink[1] = "_blank";
                        }
                        link = callLink[0];
                        target = callLink[1];
                        break;
                }
            }
            return {
                type: type,
                fun: fun,
                link: link,
                target: target,
            };
        },
        /*
			内置函数
			根据指定的align,valign,offsetX,offsetY计算坐标
		*/
        getPosition: function (obj, rEle) {
            /*
			{
	            "align": "right",
	            "vAlign": "right",
	            "offsetX": -60,
	            "offsetY": -60
	        }
			*/
            var pw = this.PD.offsetWidth,
                ph = this.PD.offsetHeight;
            var x = 0,
                y = 0;
            var left = 0,
                top = 0,
                rw = 0,
                rh = 0;
            if (!this.isUndefined(rEle)) {
                (left = parseInt(this.css(rEle, "left"))),
                    (top = parseInt(this.css(rEle, "top"))),
                    (rw = rEle.offsetWidth),
                    (rh = rEle.offsetHeight);
            }
            switch (obj["align"]) {
                case "left":
                    x = obj["offsetX"] + left;
                    break;
                case "center":
                    x = pw * 0.5 + obj["offsetX"];
                    if (left) {
                        x -= pw * 0.5 - rw * 0.5 - left;
                    }
                    break;
                case "right":
                    x = pw + obj["offsetX"];
                    if (left) {
                        x -= pw - left - rw;
                    }
                    break;
            }
            switch (obj["vAlign"]) {
                case "top":
                    y = obj["offsetY"] + top;
                    break;
                case "middle":
                    y = ph * 0.5 + obj["offsetY"] - top - rh * 0.5;
                    if (top) {
                        x -= ph * 0.5 - rh * 0.5 - top;
                    }
                    break;
                case "bottom":
                    y = ph + obj["offsetY"];
                    if (top) {
                        y -= ph - top - rh;
                    }
                    break;
            }
            return {
                x: x,
                y: y,
            };
        },
        /*
			内置函数
			向播放器界面添加一个文本
		*/
        addElement: function (attribute) {
            var thisTemp = this;
            if (this.playerType == "flashplayer") {
                return this.V.addElement(attribute);
            }
            var i = 0;
            var obj = {
                list: null,
                x: "100%",
                y: "50%",
                position: null,
                alpha: 1,
                backgroundColor: "",
                backAlpha: 1,
                backRadius: 0,
                clickEvent: "",
            };
            obj = this.standardization(obj, attribute);
            var list = obj["list"];
            if (list == null) {
                return "";
            }
            var id = "element-" + this.randomString(10);
            var ele = document.createElement("div");
            ele.className = id;
            if (obj["x"]) {
                ele.setAttribute("data-x", obj["x"]);
            }
            if (obj["y"]) {
                ele.setAttribute("data-y", obj["y"]);
            }
            if (obj["position"] != null) {
                ele.setAttribute("data-position", obj["position"].join(","));
            }

            this.PD.appendChild(ele);
            this.css(ele, {
                position: "absolute",
                filter: "alpha(opacity:" + obj["alpha"] + ")",
                opacity: obj["alpha"].toString(),
                width: "800px",
                zIndex: "20",
            });
            var bgid = "elementbg" + this.randomString(10);
            var bgAlpha = obj["alpha"].toString();
            var bgColor = obj["backgroundColor"].replace("0x", "#");
            var html = "";
            var idArr = [];
            var clickArr = [];
            if (!this.isUndefined(list) && list.length > 0) {
                var textObj, returnObj, clickEvent;
                for (i = 0; i < list.length; i++) {
                    var newEleid = "elementnew" + this.randomString(10);
                    switch (list[i]["type"]) {
                        case "image":
                        case "png":
                        case "jpg":
                        case "jpeg":
                        case "gif":
                            textObj = {
                                type: "image",
                                file: "",
                                radius: 0, //圆角弧度
                                width: 30, //定义宽，必需要定义
                                height: 30, //定义高，必需要定义
                                alpha: 1, //透明度
                                paddingLeft: 0, //左边距离
                                paddingRight: 0, //右边距离
                                paddingTop: 0,
                                paddingBottom: 0,
                                marginLeft: 0,
                                marginRight: 0,
                                marginTop: 0,
                                marginBottom: 0,
                                backgroundColor: "",
                                clickEvent: "",
                            };

                            list[i] = this.standardization(textObj, list[i]);
                            clickEvent = this.clickEvent(list[i]["clickEvent"]);
                            clickArr.push(clickEvent);
                            if (clickEvent["type"] == "link") {
                                html +=
                                    '<div class="' +
                                    newEleid +
                                    '" data-i="' +
                                    i +
                                    '"><a href="' +
                                    clickEvent["link"] +
                                    '" target="' +
                                    clickEvent["target"] +
                                    '"><img class="' +
                                    newEleid +
                                    '_image" src="' +
                                    list[i]["file"] +
                                    '" style="border:0;"></a></div>';
                            } else {
                                html +=
                                    '<div class="' +
                                    newEleid +
                                    '" data-i="' +
                                    i +
                                    '"><img class="' +
                                    newEleid +
                                    '_image" src="' +
                                    list[i]["file"] +
                                    '" style="border:0;"></div>';
                            }
                            break;
                        case "text":
                            textObj = {
                                type: "text", //说明是文本
                                text: "", //文本内容
                                color: "0xFFFFFF",
                                size: 14,
                                fontFamily: this.fontFamily,
                                leading: 0,
                                alpha: 1, //透明度
                                paddingLeft: 0, //左边距离
                                paddingRight: 0, //右边距离
                                paddingTop: 0,
                                paddingBottom: 0,
                                marginLeft: 0,
                                marginRight: 0,
                                marginTop: 0,
                                marginBottom: 0,
                                backgroundColor: "",
                                backAlpha: 1,
                                backRadius: 0, //背景圆角弧度，支持数字统一设置，也支持分开设置[30,20,20,50]，对应上左，上右，下右，下左
                                clickEvent: "",
                            };
                            list[i] = this.standardization(textObj, list[i]);
                            clickEvent = this.clickEvent(list[i]["clickEvent"]);
                            clickArr.push(clickEvent);
                            if (clickEvent["type"] == "link") {
                                html +=
                                    '<div class="' +
                                    newEleid +
                                    '" data-i="' +
                                    i +
                                    '"><div class="' +
                                    newEleid +
                                    '_bg"></div><div class="' +
                                    newEleid +
                                    '_text"><a href="' +
                                    clickEvent["link"] +
                                    '" target="' +
                                    clickEvent["target"] +
                                    '">' +
                                    list[i]["text"] +
                                    "</a></div></div>";
                            } else {
                                html +=
                                    '<div  class="' +
                                    newEleid +
                                    '" data-i="' +
                                    i +
                                    '"><div class="' +
                                    newEleid +
                                    '_bg"></div><div class="' +
                                    newEleid +
                                    '_text">' +
                                    list[i]["text"] +
                                    "</div></div>";
                            }
                            break;
                        default:
                            break;
                    }
                    idArr.push(newEleid);
                }
            }
            var objClickEvent = this.clickEvent(obj["clickEvent"]);
            ele.innerHTML =
                '<div class="' +
                bgid +
                '"></div><div class="' +
                bgid +
                '_c">' +
                html +
                "</div>";
            if (
                objClickEvent["type"] == "javaScript" ||
                objClickEvent["type"] == "actionScript"
            ) {
                var objClickHandler = function () {
                    eval(objClickEvent["fun"]);
                    thisTemp.sendJS(
                        "clickEvent",
                        clk["type"] +
                        "->" +
                        clk["fun"].replace("thisTemp.", "").replace("()", ""),
                    );
                };
                this.addListenerInside(
                    "click",
                    objClickHandler,
                    this.getByElement(bgid + "_c"),
                );
            }
            this.css(bgid + "_c", {
                position: "absolute",
                zIndex: "2",
            });
            for (i = 0; i < idArr.length; i++) {
                var clk = clickArr[i];
                if (clk["type"] == "javaScript" || clk["type"] == "actionScript") {
                    var clickHandler = function () {
                        //clk = clickArr[this.getAttribute('data-i')];
                        clk = clickArr[thisTemp.getDataset(this, "i")];
                        eval(clk["fun"]);
                        thisTemp.sendJS(
                            "clickEvent",
                            clk["type"] +
                            "->" +
                            clk["fun"].replace("thisTemp.", "").replace("()", ""),
                        );
                    };
                    this.addListenerInside(
                        "click",
                        clickHandler,
                        this.getByElement(idArr[i]),
                    );
                }
                switch (list[i]["type"]) {
                    case "image":
                    case "png":
                    case "jpg":
                    case "jpeg":
                    case "gif":
                        this.css(idArr[i], {
                            float: "left",
                            width: list[i]["width"] + "px",
                            height: list[i]["height"] + "px",
                            filter: "alpha(opacity:" + list[i]["alpha"] + ")",
                            opacity: list[i]["alpha"].toString(),
                            marginLeft: list[i]["marginLeft"] + "px",
                            marginRight: list[i]["marginRight"] + "px",
                            marginTop: list[i]["marginTop"] + "px",
                            marginBottom: list[i]["marginBottom"] + "px",
                            borderRadius: list[i]["radius"] + "px",
                            cursor: "pointer",
                        });
                        this.css(idArr[i] + "_image", {
                            width: list[i]["width"] + "px",
                            height: list[i]["height"] + "px",
                            borderRadius: list[i]["radius"] + "px",
                        });
                        break;
                    case "text":
                        this.css(idArr[i] + "_text", {
                            filter: "alpha(opacity:" + list[i]["alpha"] + ")",
                            opacity: list[i]["alpha"].toString(),
                            borderRadius: list[i]["radius"] + "px",
                            fontFamily: list[i]["font"],
                            fontSize: list[i]["size"] + "px",
                            color: list[i]["color"].replace("0x", "#"),
                            lineHeight:
                                list[i]["leading"] > 0 ? list[i]["leading"] + "px" : "",
                            paddingLeft: list[i]["paddingLeft"] + "px",
                            paddingRight: list[i]["paddingRight"] + "px",
                            paddingTop: list[i]["paddingTop"] + "px",
                            paddingBottom: list[i]["paddingBottom"] + "px",
                            whiteSpace: "nowrap",
                            position: "absolute",
                            zIndex: "3",
                            cursor: "pointer",
                        });
                        this.css(idArr[i], {
                            float: "left",
                            width: this.getByElement(idArr[i] + "_text").offsetWidth + "px",
                            height: this.getByElement(idArr[i] + "_text").offsetHeight + "px",
                            marginLeft: list[i]["marginLeft"] + "px",
                            marginRight: list[i]["marginRight"] + "px",
                            marginTop: list[i]["marginTop"] + "px",
                            marginBottom: list[i]["marginBottom"] + "px",
                        });
                        this.css(idArr[i] + "_bg", {
                            width: this.getByElement(idArr[i] + "_text").offsetWidth + "px",
                            height: this.getByElement(idArr[i] + "_text").offsetHeight + "px",
                            filter: "alpha(opacity:" + list[i]["backAlpha"] + ")",
                            opacity: list[i]["backAlpha"].toString(),
                            borderRadius: list[i]["backRadius"] + "px",
                            backgroundColor: list[i]["backgroundColor"].replace("0x", "#"),
                            position: "absolute",
                            zIndex: "2",
                        });
                        break;
                    default:
                        break;
                }
            }
            this.css(bgid, {
                width: this.getByElement(bgid + "_c").offsetWidth + "px",
                height: this.getByElement(bgid + "_c").offsetHeight + "px",
                position: "absolute",
                filter: "alpha(opacity:" + bgAlpha + ")",
                opacity: bgAlpha,
                backgroundColor: bgColor.replace("0x", "#"),
                borderRadius: obj["backRadius"] + "px",
                zIndex: "1",
            });
            this.css(ele, {
                width: this.getByElement(bgid).offsetWidth + "px",
                height: this.getByElement(bgid).offsetHeight + "px",
            });
            var eidCoor = this.calculationCoor(ele);
            this.css(ele, {
                left: eidCoor["x"] + "px",
                top: eidCoor["y"] + "px",
            });

            this.elementArr.push(ele.className);
            return ele;
        },
        /*
			内置函数
			获取元件的属性，包括x,y,width,height,alpha
		*/
        getElement: function (element) {
            if (this.playerType == "flashplayer") {
                return this.V.getElement(element);
            }
            var ele = element;
            if (this.varType(element) == "string") {
                ele = this.getByElement(element);
            }
            var coor = this.getCoor(ele);
            return {
                x: coor["x"],
                y: coor["y"],
                width: ele.offsetWidth,
                height: ele.offsetHeight,
                alpha: !this.isUndefined(this.css(ele, "opacity"))
                    ? parseFloat(this.css(ele, "opacity"))
                    : 1,
                show: this.css(ele, "display") == "none" ? false : true,
            };
        },
        /*
			内置函数
			控制元件显示和隐藏
		*/
        elementShow: function (element, show) {
            if (this.playerType == "flashplayer") {
                this.V.elementShow(element, show);
                return;
            }
            if (this.varType(element) == "string") {
                if (element) {
                    this.css(ele, "display", show == true ? "block" : "none");
                } else {
                    var arr = this.elementTempArr;
                    for (var i = 0; i < arr.length; i++) {
                        this.css(arr[i], "display", show == true ? "block" : "none");
                    }
                }
            }
        },
        /*
			内置函数
			根据节点的x,y计算在播放器里的坐标
		*/
        calculationCoor: function (ele) {
            if (this.playerType == "flashplayer") {
                return this.V.calculationCoor(ele);
            }
            if (this.isUndefined(ele)) {
                return;
            }
            if (ele == []) {
                return;
            }
            var x,
                y,
                position = [];
            var w = this.PD.offsetWidth,
                h = this.PD.offsetHeight;
            var ew = ele.offsetWidth,
                eh = ele.offsetHeight;
            if (!this.isUndefined(this.getDataset(ele, "x"))) {
                x = this.getDataset(ele, "x");
            }
            if (!this.isUndefined(this.getDataset(ele, "y"))) {
                y = this.getDataset(ele, "y");
            }
            if (!this.isUndefined(this.getDataset(ele, "position"))) {
                try {
                    position = this.getDataset(ele, "position").toString().split(",");
                } catch (event) {
                }
            }
            if (position.length > 0) {
                position.push(null, null, null, null);
                var i = 0;
                for (i = 0; i < position.length; i++) {
                    if (
                        this.isUndefined(position[i]) ||
                        position[i] == null ||
                        position[i] == "null" ||
                        position[i] == ""
                    ) {
                        position[i] = null;
                    } else {
                        position[i] = parseFloat(position[i]);
                    }
                }

                if (position[2] == null) {
                    switch (position[0]) {
                        case 0:
                            x = 0;
                            break;
                        case 1:
                            x = parseInt((w - ew) * 0.5);
                            break;
                        default:
                            x = w - ew;
                            break;
                    }
                } else {
                    switch (position[0]) {
                        case 0:
                            x = position[2];
                            break;
                        case 1:
                            x = parseInt(w * 0.5) + position[2];
                            break;
                        default:
                            x = w + position[2];
                            break;
                    }
                }
                if (position[3] == null) {
                    switch (position[1]) {
                        case 0:
                            y = 0;
                            break;
                        case 1:
                            y = parseInt((h - eh) * 0.5);
                            break;
                        default:
                            y = h - eh;
                            break;
                    }
                } else {
                    switch (position[1]) {
                        case 0:
                            y = position[3];
                            break;
                        case 1:
                            y = parseInt(h * 0.5) + position[3];
                            break;
                        default:
                            y = h + position[3];
                            break;
                    }
                }
            } else {
                if (x.substring(x.length - 1, x.length) == "%") {
                    x = Math.floor(parseInt(x.substring(0, x.length - 1)) * w * 0.01);
                }
                if (y.substring(y.length - 1, y.length) == "%") {
                    y = Math.floor(parseInt(y.substring(0, y.length - 1)) * h * 0.01);
                }
            }
            return {
                x: x,
                y: y,
            };
        },
        /*
			内置函数
			修改新增元件的坐标
		*/
        changeElementCoor: function () {
            for (var i = 0; i < this.elementArr.length; i++) {
                if (!this.isUndefined(this.getByElement(this.elementArr[i]))) {
                    if (this.getByElement(this.elementArr[i]) != []) {
                        var c = this.calculationCoor(this.getByElement(this.elementArr[i]));
                        if (c["x"] && c["y"]) {
                            this.css(this.elementArr[i], {
                                top: c["y"] + "px",
                                left: c["x"] + "px",
                            });
                        }
                    }
                }
            }
        },
        /*
			内置函数
			缓动效果集
		*/
        tween: function () {
            var Tween = {
                None: {
                    //均速运动
                    easeIn: function (t, b, c, d) {
                        return (c * t) / d + b;
                    },
                    easeOut: function (t, b, c, d) {
                        return (c * t) / d + b;
                    },
                    easeInOut: function (t, b, c, d) {
                        return (c * t) / d + b;
                    },
                },
                Quadratic: {
                    easeIn: function (t, b, c, d) {
                        return c * (t /= d) * t + b;
                    },
                    easeOut: function (t, b, c, d) {
                        return -c * (t /= d) * (t - 2) + b;
                    },
                    easeInOut: function (t, b, c, d) {
                        if ((t /= d / 2) < 1) return (c / 2) * t * t + b;
                        return (-c / 2) * (--t * (t - 2) - 1) + b;
                    },
                },
                Cubic: {
                    easeIn: function (t, b, c, d) {
                        return c * (t /= d) * t * t + b;
                    },
                    easeOut: function (t, b, c, d) {
                        return c * ((t = t / d - 1) * t * t + 1) + b;
                    },
                    easeInOut: function (t, b, c, d) {
                        if ((t /= d / 2) < 1) return (c / 2) * t * t * t + b;
                        return (c / 2) * ((t -= 2) * t * t + 2) + b;
                    },
                },
                Quartic: {
                    easeIn: function (t, b, c, d) {
                        return c * (t /= d) * t * t * t + b;
                    },
                    easeOut: function (t, b, c, d) {
                        return -c * ((t = t / d - 1) * t * t * t - 1) + b;
                    },
                    easeInOut: function (t, b, c, d) {
                        if ((t /= d / 2) < 1) return (c / 2) * t * t * t * t + b;
                        return (-c / 2) * ((t -= 2) * t * t * t - 2) + b;
                    },
                },
                Quintic: {
                    easeIn: function (t, b, c, d) {
                        return c * (t /= d) * t * t * t * t + b;
                    },
                    easeOut: function (t, b, c, d) {
                        return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
                    },
                    easeInOut: function (t, b, c, d) {
                        if ((t /= d / 2) < 1) return (c / 2) * t * t * t * t * t + b;
                        return (c / 2) * ((t -= 2) * t * t * t * t + 2) + b;
                    },
                },
                Sine: {
                    easeIn: function (t, b, c, d) {
                        return -c * Math.cos((t / d) * (Math.PI / 2)) + c + b;
                    },
                    easeOut: function (t, b, c, d) {
                        return c * Math.sin((t / d) * (Math.PI / 2)) + b;
                    },
                    easeInOut: function (t, b, c, d) {
                        return (-c / 2) * (Math.cos((Math.PI * t) / d) - 1) + b;
                    },
                },
                Exponential: {
                    easeIn: function (t, b, c, d) {
                        return t == 0 ? b : c * Math.pow(2, 10 * (t / d - 1)) + b;
                    },
                    easeOut: function (t, b, c, d) {
                        return t == d ? b + c : c * (-Math.pow(2, (-10 * t) / d) + 1) + b;
                    },
                    easeInOut: function (t, b, c, d) {
                        if (t == 0) return b;
                        if (t == d) return b + c;
                        if ((t /= d / 2) < 1)
                            return (c / 2) * Math.pow(2, 10 * (t - 1)) + b;
                        return (c / 2) * (-Math.pow(2, -10 * --t) + 2) + b;
                    },
                },
                Circular: {
                    easeIn: function (t, b, c, d) {
                        return -c * (Math.sqrt(1 - (t /= d) * t) - 1) + b;
                    },
                    easeOut: function (t, b, c, d) {
                        return c * Math.sqrt(1 - (t = t / d - 1) * t) + b;
                    },
                    easeInOut: function (t, b, c, d) {
                        if ((t /= d / 2) < 1)
                            return (-c / 2) * (Math.sqrt(1 - t * t) - 1) + b;
                        return (c / 2) * (Math.sqrt(1 - (t -= 2) * t) + 1) + b;
                    },
                },
                Elastic: {
                    easeIn: function (t, b, c, d, a, p) {
                        if (t == 0) return b;
                        if ((t /= d) == 1) return b + c;
                        if (!p) p = d * 0.3;
                        if (!a || a < Math.abs(c)) {
                            a = c;
                            var s = p / 4;
                        } else var s = (p / (2 * Math.PI)) * Math.asin(c / a);
                        return (
                            -(
                                a *
                                Math.pow(2, 10 * (t -= 1)) *
                                Math.sin(((t * d - s) * (2 * Math.PI)) / p)
                            ) + b
                        );
                    },
                    easeOut: function (t, b, c, d, a, p) {
                        if (t == 0) return b;
                        if ((t /= d) == 1) return b + c;
                        if (!p) p = d * 0.3;
                        if (!a || a < Math.abs(c)) {
                            a = c;
                            var s = p / 4;
                        } else var s = (p / (2 * Math.PI)) * Math.asin(c / a);
                        return (
                            a *
                            Math.pow(2, -10 * t) *
                            Math.sin(((t * d - s) * (2 * Math.PI)) / p) +
                            c +
                            b
                        );
                    },
                    easeInOut: function (t, b, c, d, a, p) {
                        if (t == 0) return b;
                        if ((t /= d / 2) == 2) return b + c;
                        if (!p) p = d * (0.3 * 1.5);
                        if (!a || a < Math.abs(c)) {
                            a = c;
                            var s = p / 4;
                        } else var s = (p / (2 * Math.PI)) * Math.asin(c / a);
                        if (t < 1)
                            return (
                                -0.5 *
                                (a *
                                    Math.pow(2, 10 * (t -= 1)) *
                                    Math.sin(((t * d - s) * (2 * Math.PI)) / p)) +
                                b
                            );
                        return (
                            a *
                            Math.pow(2, -10 * (t -= 1)) *
                            Math.sin(((t * d - s) * (2 * Math.PI)) / p) *
                            0.5 +
                            c +
                            b
                        );
                    },
                },
                Back: {
                    easeIn: function (t, b, c, d, s) {
                        if (s == undefined) s = 1.70158;
                        return c * (t /= d) * t * ((s + 1) * t - s) + b;
                    },
                    easeOut: function (t, b, c, d, s) {
                        if (s == undefined) s = 1.70158;
                        return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
                    },
                    easeInOut: function (t, b, c, d, s) {
                        if (s == undefined) s = 1.70158;
                        if ((t /= d / 2) < 1)
                            return (c / 2) * (t * t * (((s *= 1.525) + 1) * t - s)) + b;
                        return (
                            (c / 2) * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2) + b
                        );
                    },
                },
                Bounce: {
                    easeIn: function (t, b, c, d) {
                        return c - Tween.Bounce.easeOut(d - t, 0, c, d) + b;
                    },
                    easeOut: function (t, b, c, d) {
                        if ((t /= d) < 1 / 2.75) {
                            return c * (7.5625 * t * t) + b;
                        } else if (t < 2 / 2.75) {
                            return c * (7.5625 * (t -= 1.5 / 2.75) * t + 0.75) + b;
                        } else if (t < 2.5 / 2.75) {
                            return c * (7.5625 * (t -= 2.25 / 2.75) * t + 0.9375) + b;
                        } else {
                            return c * (7.5625 * (t -= 2.625 / 2.75) * t + 0.984375) + b;
                        }
                    },
                    easeInOut: function (t, b, c, d) {
                        if (t < d / 2) return Tween.Bounce.easeIn(t * 2, 0, c, d) * 0.5 + b;
                        else
                            return (
                                Tween.Bounce.easeOut(t * 2 - d, 0, c, d) * 0.5 + c * 0.5 + b
                            );
                    },
                },
            };
            return Tween;
        },
        /*
			接口函数
			缓动效果
			ele:Object=需要缓动的对象,
			parameter:String=需要改变的属性：x,y,width,height,alpha,
			effect:String=效果名称,
			start:Int=起始值,
			end:Int=结束值,
			speed:Number=运动的总秒数，支持小数
		*/
        animate: function (attribute) {
            if (this.playerType == "flashplayer") {
                return this.V.animate(attribute);
            }
            var thisTemp = this;
            var animateId = "animate_" + this.randomString();
            var obj = {
                element: null,
                parameter: "x",
                static: false,
                effect: "None.easeIn",
                start: null,
                end: null,
                speed: 0,
                overStop: false,
                pauseStop: false,
                //暂停播放时缓动是否暂停
                callBack: null,
            };
            obj = this.standardization(obj, attribute);
            if (obj["element"] == null || obj["speed"] == 0) {
                return false;
            }
            var w = this.PD.offsetWidth,
                h = this.PD.offsetHeight;
            var effArr = (obj["effect"] + ".").split(".");
            var tweenFun = this.tween()[effArr[0]][effArr[1]];
            var eleCoor = {
                x: 0,
                y: 0,
            };
            if (this.isUndefined(tweenFun)) {
                return false;
            }
            //先将该元件从元件数组里删除，让其不再跟随播放器的尺寸改变而改变位置
            var def = this.arrIndexOf(this.elementArr, obj["element"].className);
            if (def > -1) {
                this.elementTempArr.push(obj["element"].className);
                this.elementArr.splice(def, 1);
            }
            //var run = true;
            var css = {};
            //对传递的参数进行转化，x和y转化成left,top
            var pm = this.getElement(obj["element"]); //包含x,y,width,height,alpha属性
            var t = 0; //当前时间
            var b = 0; //初始值
            var c = 0; //变化量
            var d = obj["speed"] * 1000; //持续时间
            var timerTween = null;
            var tweenObj = null;
            var start = obj["start"] == null ? "" : obj["start"].toString();
            var end = obj["end"] == null ? "" : obj["end"].toString();
            switch (obj["parameter"]) {
                case "x":
                    if (obj["start"] == null) {
                        b = pm["x"];
                    } else {
                        if (start.substring(start.length - 1, start.length) == "%") {
                            b = parseInt(start) * w * 0.01;
                        } else {
                            b = parseInt(start);
                        }
                    }
                    if (obj["end"] == null) {
                        c = pm["x"] - b;
                    } else {
                        if (end.substring(end.length - 1, end.length) == "%") {
                            c = parseInt(end) * w * 0.01 - b;
                        } else if (
                            end.substring(0, 1) == "-" ||
                            end.substring(0, 1) == "+"
                        ) {
                            if (this.varType(obj["end"]) == "number") {
                                c = parseInt(obj["end"]) - b;
                            } else {
                                c = parseInt(end);
                            }
                        } else {
                            c = parseInt(end) - b;
                        }
                    }
                    break;
                case "y":
                    if (obj["start"] == null) {
                        b = pm["y"];
                    } else {
                        if (start.substring(start.length - 1, start.length) == "%") {
                            b = parseInt(start) * h * 0.01;
                        } else {
                            b = parseInt(start);
                        }
                    }
                    if (obj["end"] == null) {
                        c = pm["y"] - b;
                    } else {
                        if (end.substring(end.length - 1, end.length) == "%") {
                            c = parseInt(end) * h * 0.01 - b;
                        } else if (
                            end.substring(0, 1) == "-" ||
                            end.substring(0, 1) == "+"
                        ) {
                            if (this.varType(obj["end"]) == "number") {
                                c = parseInt(obj["end"]) - b;
                            } else {
                                c = parseInt(end);
                            }
                        } else {
                            c = parseInt(end) - b;
                        }
                    }
                    break;
                case "alpha":
                    if (obj["start"] == null) {
                        b = pm["alpha"] * 100;
                    } else {
                        if (start.substring(start.length - 1, start.length) == "%") {
                            b = parseInt(obj["start"]);
                        } else {
                            b = parseInt(obj["start"] * 100);
                        }
                    }
                    if (obj["end"] == null) {
                        c = pm["alpha"] * 100 - b;
                    } else {
                        if (end.substring(end.length - 1, end.length) == "%") {
                            c = parseInt(end) - b;
                        } else if (
                            end.substring(0, 1) == "-" ||
                            end.substring(0, 1) == "+"
                        ) {
                            if (this.varType(obj["end"]) == "number") {
                                c = parseInt(obj["end"]) * 100 - b;
                            } else {
                                c = parseInt(obj["end"]) * 100;
                            }
                        } else {
                            c = parseInt(obj["end"]) * 100 - b;
                        }
                    }
                    break;
            }
            var callBack = function () {
                var index = thisTemp.arrIndexOf(
                    thisTemp.animateElementArray,
                    animateId,
                );
                if (index > -1) {
                    thisTemp.animateArray.splice(index, 1);
                    thisTemp.animateElementArray.splice(index, 1);
                }
                index = thisTemp.arrIndexOf(thisTemp.animatePauseArray, animateId);
                if (index > -1) {
                    thisTemp.animatePauseArray.splice(index, 1);
                }
                if (
                    obj["callBack"] != null &&
                    obj["element"] &&
                    obj["callBack"] != "callBack" &&
                    obj["callBack"] != "tweenX" &&
                    obj["tweenY"] != "callBack" &&
                    obj["callBack"] != "tweenAlpha"
                ) {
                    var cb = eval(obj["callBack"]);
                    cb(obj["element"]);
                    obj["callBack"] = null;
                }
            };
            var stopTween = function () {
                if (timerTween != null) {
                    if (timerTween.runing) {
                        timerTween.stop();
                    }
                    timerTween = null;
                }
            };
            var tweenX = function () {
                if (t < d) {
                    t += 10;
                    css = {
                        left: Math.ceil(tweenFun(t, b, c, d)) + "px",
                    };
                    if (obj["static"]) {
                        eleCoor = thisTemp.calculationCoor(obj["element"]);
                        css["top"] = eleCoor["y"] + "px";
                    }
                    thisTemp.css(obj["element"], css);
                } else {
                    stopTween();
                    try {
                        var defX = this.arrIndexOf(
                            this.elementTempArr,
                            obj["element"].className,
                        );
                        if (defX > -1) {
                            this.elementTempArr.splice(defX, 1);
                        }
                    } catch (event) {
                    }
                    thisTemp.elementArr.push(obj["element"].className);
                    callBack();
                }
            };
            var tweenY = function () {
                if (t < d) {
                    t += 10;
                    css = {
                        top: Math.ceil(tweenFun(t, b, c, d)) + "px",
                    };
                    if (obj["static"]) {
                        eleCoor = thisTemp.calculationCoor(obj["element"]);
                        css["left"] = eleCoor["x"] + "px";
                    }
                    thisTemp.css(obj["element"], css);
                } else {
                    stopTween();
                    try {
                        var defY = this.arrIndexOf(
                            this.elementTempArr,
                            obj["element"].className,
                        );
                        if (defY > -1) {
                            this.elementTempArr.splice(defY, 1);
                        }
                    } catch (event) {
                    }
                    thisTemp.elementArr.push(obj["element"].className);
                    callBack();
                }
            };
            var tweenAlpha = function () {
                if (t < d) {
                    t += 10;
                    eleCoor = thisTemp.calculationCoor(obj["element"]);
                    var ap = Math.ceil(tweenFun(t, b, c, d)) * 0.01;
                    css = {
                        filter: "alpha(opacity:" + ap + ")",
                        opacity: ap.toString(),
                    };
                    if (obj["static"]) {
                        eleCoor = thisTemp.calculationCoor(obj["element"]);
                        css["top"] = eleCoor["y"] + "px";
                        css["left"] = eleCoor["x"] + "px";
                    }
                    thisTemp.css(obj["element"], css);
                } else {
                    stopTween();
                    try {
                        var defA = this.arrIndexOf(
                            this.elementTempArr,
                            obj["element"].className,
                        );
                        if (defA > -1) {
                            this.elementTempArr.splice(defA, 1);
                        }
                    } catch (event) {
                    }
                    thisTemp.elementArr.push(obj["element"].className);
                    callBack();
                }
            };
            switch (obj["parameter"]) {
                case "x":
                    tweenObj = tweenX;
                    break;
                case "y":
                    tweenObj = tweenY;
                    break;
                case "alpha":
                    tweenObj = tweenAlpha;
                    break;
                default:
                    break;
            }
            timerTween = new thisTemp.timer(10, tweenObj);
            timerTween.callBackFunction = callBack;
            if (obj["overStop"]) {
                var mouseOver = function () {
                    if (timerTween != null && timerTween.runing) {
                        timerTween.stop();
                    }
                };
                this.addListenerInside("mouseover", mouseOver, obj["element"]);
                var mouseOut = function () {
                    var start = true;
                    if (obj["pauseStop"] && thisTemp.getMetaDate()["paused"]) {
                        start = false;
                    }
                    if (timerTween != null && !timerTween.runing && start) {
                        timerTween.start();
                    }
                };
                this.addListenerInside("mouseout", mouseOut, obj["element"]);
            }

            this.animateArray.push(timerTween);
            this.animateElementArray.push(animateId);
            if (obj["pauseStop"]) {
                this.animatePauseArray.push(animateId);
            }
            return animateId;
        },
        /*
			接口函数函数
			继续运行animate
		*/
        animateResume: function (id) {
            if (this.playerType == "flashplayer") {
                this.V.animateResume(this.isUndefined(id) ? "" : id);
                return;
            }
            var arr = [];
            if (id != "" && !this.isUndefined(id) && id != "pause") {
                arr.push(id);
            } else {
                if (id === "pause") {
                    arr = this.animatePauseArray;
                } else {
                    arr = this.animateElementArray;
                }
            }
            for (var i = 0; i < arr.length; i++) {
                var index = this.arrIndexOf(this.animateElementArray, arr[i]);
                if (index > -1) {
                    this.animateArray[index].start();
                }
            }
        },
        /*
			接口函数
			暂停运行animate
		*/
        animatePause: function (id) {
            if (this.playerType == "flashplayer") {
                this.V.animatePause(this.isUndefined(id) ? "" : id);
                return;
            }
            var arr = [];
            if (id != "" && !this.isUndefined(id) && id != "pause") {
                arr.push(id);
            } else {
                if (id === "pause") {
                    arr = this.animatePauseArray;
                } else {
                    arr = this.animateElementArray;
                }
            }
            for (var i = 0; i < arr.length; i++) {
                var index = this.arrIndexOf(this.animateElementArray, arr[i]);
                if (index > -1) {
                    this.animateArray[index].stop();
                }
            }
        },
        /*
			内置函数
			根据ID删除数组里对应的内容
		*/
        deleteAnimate: function (id) {
            if (this.playerType == "flashplayer" && this.V) {
                try {
                    this.V.deleteAnimate(id);
                } catch (event) {
                    this.log(event);
                }
                return;
            }
            var index = this.arrIndexOf(this.animateElementArray, id);
            if (index > -1) {
                this.animateArray[index].callBackFunction();
                this.animateArray.splice(index, 1);
                this.animateElementArray.splice(index, 1);
            }
        },
        /*
			内置函数
			删除外部新建的元件
		*/
        deleteElement: function (ele) {
            if (this.playerType == "flashplayer" && this.V) {
                try {
                    this.V.deleteElement(ele);
                } catch (event) {
                }
                return;
            }
            //先将该元件从元件数组里删除，让其不再跟随播放器的尺寸改变而改变位置
            var def = this.arrIndexOf(this.elementArr, ele.className);
            if (def > -1) {
                this.elementArr.splice(def, 1);
            }
            try {
                def = this.arrIndexOf(this.elementTempArr, ele.className);
                if (def > -1) {
                    this.elementTempArr.splice(def, 1);
                }
            } catch (event) {
            }
            this.deleteAnimate(ele.className);
            this.deleteChild(ele);
        },
        /*
			--------------------------------------------------------------
			共用函数部分
			以下函数并非只能在本程序中使用，也可以在页面其它项目中使用
			根据ID或className获取元素对象
		*/
        getByElement: function (obj, parent) {
            if (this.isUndefined(parent)) {
                parent = document;
            }
            var num = obj.substr(0, 1);
            var res = [];
            if (num != "#") {
                if (num == ".") {
                    obj = obj.substr(1, obj.length);
                }
                if (parent.getElementsByClassName) {
                    res = parent.getElementsByClassName(obj);
                    if (!res.length) {
                        return null;
                    }
                } else {
                    var reg = new RegExp(" " + obj + " ", "i");
                    var ele = parent.getElementsByTagName("*");
                    for (var i = 0; i < ele.length; i++) {
                        if (reg.test(" " + ele[i].className + " ")) {
                            res.push(ele[i]);
                        }
                    }
                }
                if (res.length > 0) {
                    res = res[0];
                } else {
                    res = null;
                }
            } else {
                if (num == "#") {
                    obj = obj.substr(1, obj.length);
                }
                try {
                    res = document.getElementById(obj);
                } catch (event) {
                    res = null;
                }
            }
            return res;
        },
        /*
		 	共用函数
			功能：修改样式或获取指定样式的值，
				elem：ID对象或ID对应的字符，如果多个对象一起设置，则可以使用数组
				attribute：样式名称或对象，如果是对象，则省略掉value值
				value：attribute为样式名称时，定义的样式值
				示例一：
				this.css(ID,'width','100px');
				示例二：
				this.css('id','width','100px');
				示例三：
				this.css([ID1,ID2,ID3],'width','100px');
				示例四：
				this.css(ID,{
					width:'100px',
					height:'100px'
				});
				示例五(获取宽度)：
				var width=this.css(ID,'width');
		*/
        css: function (elem, attribute, value) {
            var i = 0;
            var k = "";
            if (this.varType(elem) == "array") {
                //数组
                for (i = 0; i < elem.length; i++) {
                    var el;
                    if (typeof elem[i] == "string") {
                        el = this.getByElement(elem[i]);
                    } else {
                        el = elem[i];
                    }
                    if (typeof attribute != "object") {
                        if (!this.isUndefined(value)) {
                            el.style[attribute] = value;
                        }
                    } else {
                        for (k in attribute) {
                            if (!this.isUndefined(attribute[k])) {
                                try {
                                    el.style[k] = attribute[k];
                                } catch (event) {
                                    this.log(event);
                                }
                            }
                        }
                    }
                }
                return;
            }
            if (this.varType(elem) == "string") {
                elem = this.getByElement(elem);
            }
            if (this.varType(attribute) != "object") {
                if (!this.isUndefined(value)) {
                    elem.style[attribute] = value;
                } else {
                    if (!this.isUndefined(this.getStyle(elem, attribute))) {
                        return this.getStyle(elem, attribute);
                    } else {
                        return false;
                    }
                }
            } else {
                for (k in attribute) {
                    if (!this.isUndefined(attribute[k])) {
                        elem.style[k] = attribute[k];
                    }
                }
            }
        },
        /*
			内置函数
			兼容型获取style
		*/
        getStyle: function (obj, attr) {
            if (!this.isUndefined(obj.style[attr])) {
                return obj.style[attr];
            } else {
                if (obj.currentStyle) {
                    return obj.currentStyle[attr];
                } else {
                    return getComputedStyle(obj, false)[attr];
                }
            }
        },
        /*
			共用函数
			判断变量是否存在或值是否为undefined
		*/
        isUndefined: function (value) {
            try {
                if (
                    value === "undefined" ||
                    value === undefined ||
                    value === null ||
                    value === "NaN" ||
                    value === NaN
                ) {
                    return true;
                }
            } catch (event) {
                this.log(event);
                return true;
            }
            return false;
        },
        /*
		 	共用函数
			外部监听函数
		*/
        addListener: function (name, funName) {
            if (name && funName) {
                if (this.playerType == "flashplayer") {
                    var ff = ""; //定义用来向flashplayer传递的函数字符
                    if (this.varType(funName) == "function") {
                        ff = this.getParameterNames(funName);
                    }
                    this.V.addListener(name, ff);
                    return;
                }
                var have = false;
                for (var i = 0; i < this.listenerJsArr.length; i++) {
                    var arr = this.listenerJsArr[i];
                    if (arr[0] == name && arr[1] == funName) {
                        have = true;
                        break;
                    }
                }
                if (!have) {
                    this.listenerJsArr.push([name, funName]);
                }
            }
        },
        /*
			共用函数
			外部删除监听函数
		*/
        removeListener: function (name, funName) {
            if (name && funName) {
                if (this.playerType == "flashplayer") {
                    var ff = ""; //定义用来向flashplayer传递的函数字符
                    if (this.varType(funName) == "function") {
                        ff = this.getParameterNames(funName);
                    }
                    this.V.removeListener(name, ff);
                    return;
                }
                for (var i = 0; i < this.listenerJsArr.length; i++) {
                    var arr = this.listenerJsArr[i];
                    if (arr[0] == name && arr[1] == funName) {
                        this.listenerJsArr.splice(i, 1);
                        break;
                    }
                }
            }
        },
        /*
			内部监听函数，调用方式：
			this.addListenerInside('click',function(event){},[ID]);
			d值为空时，则表示监听当前的视频播放器
		*/
        addListenerInside: function (e, f, d, t) {
            if (this.isUndefined(t)) {
                t = false;
            }
            var o = this.V;
            if (!this.isUndefined(d)) {
                o = d;
            }
            if (o.addEventListener) {
                try {
                    o.addEventListener(e, f, t);
                } catch (event) {
                    this.log(event);
                }
            } else if (o.attachEvent) {
                try {
                    o.attachEvent("on" + e, f);
                } catch (event) {
                    this.log(event);
                }
            } else {
                o["on" + e] = f;
            }
        },
        /*
			删除内部监听函数，调用方式：
			this.removeListenerInside('click',function(event){}[,ID]);
			d值为空时，则表示监听当前的视频播放器
		*/
        removeListenerInside: function (e, f, d, t) {
            /*if(this.playerType=='flashplayer' && this.getParameterNames(f) && this.isUndefined(d)) {
				return;
			}*/
            if (this.isUndefined(t)) {
                t = false;
            }
            var o = this.V;
            if (!this.isUndefined(d)) {
                o = d;
            }
            if (o.removeEventListener) {
                try {
                    this.addNum--;
                    o.removeEventListener(e, f, t);
                } catch (e) {
                }
            } else if (o.detachEvent) {
                try {
                    o.detachEvent("on" + e, f);
                } catch (e) {
                }
            } else {
                o["on" + e] = null;
            }
        },
        /*
			共用函数
			统一分配监听，以达到跟as3同样效果
		*/
        sendJS: function (name, val) {
            if (this.adPlayerPlay && name.substr(-2) != "Ad") {
                return;
            }
            if (this.isUndefined(name)) {
                return;
            }
            var list = this.listenerJsArr;
            var obj = this.vars["variable"];
            if (this.vars["debug"]) {
                this.log(name + ":" + val);
            }
            for (var i = 0; i < list.length; i++) {
                var arr = list[i];
                if (arr[0] == name) {
                    if (!this.isUndefined(val)) {
                        switch (arr[1].length) {
                            case 1:
                                arr[1](val);
                                break;
                            case 2:
                                arr[1](val, obj);
                                break;
                            default:
                                arr[1]();
                                break;
                        }
                    } else {
                        arr[1](obj);
                    }
                }
            }
        },
        /*
			共用函数
			获取函数名称，如 function ckplayer(){} var fun=ckplayer，则getParameterNames(fun)=ckplayer
		*/
        getParameterNames: function (fn) {
            if (this.varType(fn) !== "function") {
                return false;
            }
            var COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
            var code = fn.toString().replace(COMMENTS, "");
            var result = code.slice(code.indexOf(" ") + 1, code.indexOf("("));
            return result === null ? false : result;
        },
        /*
			共用函数
			时间替换
		*/
        replaceTime: function (str, obj) {
            //var timeStrArr = ['[$timeh]', '[$timei]', '[$timeI]', '[$times]', '[$timeS]', '[$durationh]', '[$durationi]', '[$durationI]', '[$durations]', '[$durationS]','[$liveTimey]', '[$liveTimeY]', '[$liveTimem]', '[$liveTimed]', '[$liveTimeh]', '[$liveTimei]', '[$liveTimes]', '[$liveLanguage]'];
            for (var k in obj) {
                str = str.replace("[$" + k + "]", obj[k]);
            }
            return str;
        },
        /*
			共用函数
			格式化时分秒
			t:Int：秒数,dt:总时间的秒数
		*/
        formatTime: function (t, dt, str) {
            if (this.isUndefined(t) || isNaN(t)) {
                seconds = 0;
            }
            if (this.isUndefined(dt) || isNaN(dt)) {
                dt = 0;
            }
            var minuteS = Math.floor(t / 60); //将秒数直接转化成分钟取整，这个可以得到如80分钟
            var minute = minuteS; //获取准确的分钟
            var hourS = Math.floor(t / 3600); //将秒数直接转化成小时取整，这个可以得到100小时
            var second = t % 60;
            if (minuteS >= 60) {
                minute = Math.floor(minuteS % 60);
            }
            //总时间
            var hminuteS = Math.floor(dt / 60); //将秒数直接转化成分钟取整，这个可以得到如80分钟
            var hminute = hminuteS; //获取准确的分钟
            var hhourS = Math.floor(dt / 3600); //将秒数直接转化成小时取整，这个可以得到100小时
            var hsecond = dt % 60;
            if (hminuteS >= 60) {
                hminute = Math.floor(hminuteS % 60);
            }
            //当前时间
            var nowDate = new Date();
            var obj = {
                timeh: hourS, //时
                timei: minute, //分
                timeI: minuteS, //只有分
                times: second, //秒
                timeS: t, //只有秒
                durationh: hhourS, //时
                durationi: hminute, //分
                durationI: hminuteS, //只有分
                durations: hsecond, //秒
                durationS: dt, //只有秒
                liveTimey: nowDate.getYear(), //获取当前年份(2位)
                liveTimeY: nowDate.getFullYear(), //获取完整的年份(4位,1970-????)
                liveTimem: nowDate.getMonth() + 1, //获取当前月份(0-11,0代表1月)
                liveTimed: nowDate.getDate(), // 获取当前日(1-31)
                liveTimeh: nowDate.getHours(), // 获取当前小时数(0-23)
                liveTimei: nowDate.getMinutes(), // 获取当前分钟数(0-59)
                liveTimes: nowDate.getSeconds(), // 获取当前秒数(0-59)
            };
            for (var k in obj) {
                if (obj[k] < 10) {
                    obj[k] = "0" + Math.floor(obj[k]);
                } else {
                    obj[k] = Math.floor(obj[k]).toString();
                }
            }
            return this.replaceTime(str, obj);
        },
        /*
			共用函数
			获取一个随机字符
			len：随机字符长度
		*/
        randomString: function (len) {
            len = len || 16;
            var chars = "abcdefghijklmnopqrstuvwxyz";
            var maxPos = chars.length;
            var val = "";
            for (i = 0; i < len; i++) {
                val += chars.charAt(Math.floor(Math.random() * maxPos));
            }
            return "ch" + val;
        },
        /*
			共用函数
			获取字符串长度,中文算两,英文数字算1
		*/
        getStringLen: function (str) {
            if (this.isUndefined(str)) {
                return 0;
            }
            var len = 0;
            for (var i = 0; i < str.length; i++) {
                if (str.charCodeAt(i) > 127 || str.charCodeAt(i) == 94) {
                    len += 2;
                } else {
                    len++;
                }
            }
            return len;
        },
        /*
			内部函数
			用来为ajax提供支持
		*/
        createXHR: function () {
            if (window.XMLHttpRequest) {
                //IE7+、Firefox、Opera、Chrome 和Safari
                return new XMLHttpRequest();
            } else if (window.ActiveXObject) {
                //IE6 及以下
                try {
                    return new ActiveXObject("Microsoft.XMLHTTP");
                } catch (event) {
                    try {
                        return new ActiveXObject("Msxml2.XMLHTTP");
                    } catch (event) {
                        this.eject(this.errorList[7]);
                    }
                }
            } else {
                this.eject(this.errorList[8]);
            }
        },
        /*
			共用函数
			ajax调用
		*/
        ajax: function (cObj) {
            var thisTemp = this;
            var callback = null;
            var obj = {
                method: "get", //请求类型
                dataType: "json", //请求的数据类型
                charset: "utf-8",
                async: false, //true表示异步，false表示同步
                url: "",
                data: null,
                success: null,
                error: null,
            };
            if (this.varType(cObj) != "object") {
                this.eject(this.errorList[9]);
                return;
            }
            obj = this.standardization(obj, cObj);
            if (
                obj.dataType === "json" ||
                obj.dataType === "text" ||
                obj.dataType === "html" ||
                obj.dataType === "xml"
            ) {
                var xhr = this.createXHR();
                callback = function () {
                    //判断http的交互是否成功
                    if (xhr.status == 200) {
                        if (thisTemp.isUndefined(obj.success)) {
                            return;
                        }
                        if (obj.dataType === "json") {
                            try {
                                obj.success(eval("(" + xhr.responseText + ")")); //回调传递参数
                            } catch (event) {
                                if (!thisTemp.isUndefined(obj["error"])) {
                                    obj.error(event);
                                }
                            }
                        } else {
                            obj.success(xhr.responseText); //回调传递参数
                        }
                    } else {
                        obj.success(null);
                        thisTemp.eject(thisTemp.errorList[10], "Ajax.status:" + xhr.status);
                    }
                };
                obj.url =
                    obj.url.indexOf("?") == -1
                        ? obj.url + "?rand=" + this.randomString(6)
                        : obj.url;
                obj.data = this.formatParams(obj.data); //通过params()将名值对转换成字符串
                if (obj.method === "get" && !this.isUndefined(obj.data)) {
                    if (obj.data != "") {
                        if (obj.url.indexOf("?") == -1) {
                            obj.url += "?" + obj.data;
                        } else {
                            obj.url += "&" + obj.data;
                        }
                    }
                }
                if (obj.async === true) {
                    //true表示异步，false表示同步
                    xhr.onreadystatechange = function () {
                        if (xhr.readyState == 4 && callback != null) {
                            //判断对象的状态是否交互完成
                            callback(); //回调
                        }
                    };
                }
                xhr.open(obj.method, obj.url, obj.async);
                if (obj.method === "post") {
                    try {
                        xhr.setRequestHeader(
                            "Content-Type",
                            "application/x-www-form-urlencoded",
                        );
                        xhr.setRequestHeader("charset", obj["charset"]);
                        xhr.send(obj.data);
                    } catch (event) {
                        callback();
                    }
                } else {
                    try {
                        xhr.send(null); //get方式则填null
                    } catch (event) {
                        callback();
                    }
                }
                if (obj.async === false) {
                    //同步
                    callback();
                }
            } else if (obj.dataType === "jsonp") {
                var oHead = document.getElementsByTagName("head")[0];
                var oScript = document.createElement("script");
                var callbackName = "callback" + new Date().getTime();
                var params = this.formatParams(obj.data) + "&callback=" + callbackName; //按时间戳拼接字符串
                callback = obj.success;
                //拼接好src
                oScript.src = obj.url.split("?") + "?" + params;
                //插入script标签
                oHead.insertBefore(oScript, oHead.firstChild);
                //jsonp的回调函数
                window[callbackName] = function (json) {
                    callback(json);
                    oHead.removeChild(oScript);
                };
            }
        },
        /*
			内置函数
			动态加载js
		*/
        loadJs: function (path, success) {
            var oHead = document.getElementsByTagName("HEAD").item(0);
            var oScript = document.createElement("script");
            oScript.type = "text/javascript";
            oScript.src = this.getNewUrl(path);
            oHead.appendChild(oScript);
            oScript.onload = function () {
                success();
            };
        },
        /*
			共用函数
			排除IE6-9
		*/
        isMsie: function () {
            var browser = navigator.appName;
            var b_version = navigator.appVersion;
            var version = b_version.split(";");
            var trim_Version = "";
            if (version.length > 1) {
                trim_Version = version[1].replace(/[ ]/g, "");
            }
            if (
                browser == "Microsoft Internet Explorer" &&
                (trim_Version == "MSIE6.0" ||
                    trim_Version == "MSIE7.0" ||
                    trim_Version == "MSIE8.0" ||
                    trim_Version == "MSIE9.0" ||
                    trim_Version == "MSIE10.0")
            ) {
                return false;
            }
            return true;
        },
        /*
			共用函数
			判断是否安装了flashplayer
		*/
        uploadFlash: function () {
            var swf;
            if (navigator.userAgent.indexOf("MSIE") > 0) {
                try {
                    var swf = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
                    return true;
                } catch (e) {
                    return false;
                }
            }
            if (navigator.userAgent.indexOf("Firefox") > 0) {
                swf = navigator.plugins["Shockwave Flash"];
                if (swf) {
                    return true;
                } else {
                    return false;
                }
            }
            return true;
        },
        /*
			共用函数
			检测浏览器是否支持HTML5-Video
		*/
        supportVideo: function () {
            if (!this.isMsie()) {
                return false;
            }
            if (!!document.createElement("video").canPlayType) {
                var vidTest = document.createElement("video");
                var oggTest;
                try {
                    oggTest = vidTest.canPlayType('video/ogg; codecs="theora, vorbis"');
                } catch (error) {
                    oggTest = false;
                }
                if (!oggTest) {
                    var h264Test;
                    try {
                        h264Test = vidTest.canPlayType(
                            'video/mp4; codecs="avc1.42E01E, mp4a.40.2"',
                        );
                    } catch (error) {
                        h264Test = false;
                    }
                    if (!h264Test) {
                        return false;
                    } else {
                        if (h264Test == "probably") {
                            return true;
                        } else {
                            return false;
                        }
                    }
                } else {
                    if (oggTest == "probably") {
                        return true;
                    } else {
                        return false;
                    }
                }
            } else {
                return false;
            }
        },
        /*
			共用函数
			获取属性值
		*/
        getDataset: function (ele, z) {
            try {
                return ele.dataset[z];
            } catch (error) {
                try {
                    return ele.getAttribute("data-" + z);
                } catch (error) {
                    return false;
                }
            }
        },
        /*
			共用函数
			返回flashplayer的对象
		*/
        getObjectById: function (id) {
            var x = null;
            var y = this.getByElement("#" + id);
            var r = "embed";
            if (y && y.nodeName == "OBJECT") {
                if (this.varType(y.SetVariable) != "undefined") {
                    x = y;
                } else {
                    var z = y.getElementsByTagName(r)[0];
                    if (z) {
                        x = z;
                    }
                }
            }
            return x;
        },
        /*
			共用函数
			对象转地址字符串
		*/
        formatParams: function (data) {
            var arr = [];
            for (var i in data) {
                arr.push(encodeURIComponent(i) + "=" + encodeURIComponent(data[i]));
            }
            return arr.join("&");
        },
        /*
			内置函数
			对地址进行冒泡排序
		*/
        arrSort: function (arr) {
            var temp = [];
            for (var i = 0; i < arr.length; i++) {
                for (var j = 0; j < arr.length - i; j++) {
                    if (!this.isUndefined(arr[j + 1]) && arr[j][3] < arr[j + 1][3]) {
                        temp = arr[j + 1];
                        arr[j + 1] = arr[j];
                        arr[j] = temp;
                    }
                }
            }
            return arr;
        },
        /*
			共用函数
			获取文件名称
		*/
        getFileName: function (filepath) {
            if (!filepath) return "";
            return filepath.replace(/(.*\/)*([^.]+).*/gi, "$2");
        },
        /*
			内置函数
			判断文件后缀
		*/
        getFileExt: function (filepath) {
            if (filepath != "" && !this.isUndefined(filepath)) {
                if (filepath.indexOf("?") > -1) {
                    filepath = filepath.split("?")[0];
                }
                var pos = "." + filepath.replace(/.+\./, "");
                return pos.toLowerCase();
            }
            return "";
        },
        /*
			内置函数
			判断是否是移动端
		*/
        isMobile: function () {
            if (
                navigator.userAgent
                    .toLowerCase()
                    .match(
                        /(iphone|ipad|ipod|android|ios|midp|windows mobile|windows ce|rv:1.2.3.4|ucweb)/i,
                    )
            ) {
                return true;
            }
            return false;
        },
        /*
			内置函数
			搜索字符串str是否包含key
		*/
        isContains: function (str, key) {
            return str.indexOf(key) > -1;
        },
        /*
			内置函数
			给地址添加随机数
		*/
        getNewUrl: function (url) {
            if (this.isContains(url, "?")) {
                return (url += "&" + this.randomString(8) + "=" + this.randomString(8));
            } else {
                return (url += "?" + this.randomString(8) + "=" + this.randomString(8));
            }
        },
        /*
			共用函数
			获取clientX和clientY
		*/
        client: function (event) {
            var eve = event || window.event;
            if (this.isUndefined(eve)) {
                eve = {
                    clientX: 0,
                    clientY: 0,
                };
            }
            return {
                x:
                    eve.clientX +
                    (document.documentElement.scrollLeft || this.body.scrollLeft) -
                    this.pdCoor["x"],
                y:
                    eve.clientY +
                    (document.documentElement.scrollTop || this.body.scrollTop) -
                    this.pdCoor["y"],
            };
        },
        /*
			内置函数
			获取节点的绝对坐标
		*/
        getCoor: function (obj) {
            var coor = this.getXY(obj);
            return {
                x: coor["x"] - this.pdCoor["x"],
                y: coor["y"] - this.pdCoor["y"],
            };
        },
        getXY: function (obj) {
            var parObj = obj;
            var left = obj.offsetLeft;
            var top = obj.offsetTop;

            while ((parObj = parObj.offsetParent)) {
                left += parObj.offsetLeft;
                top += parObj.offsetTop;
            }
            return {
                x: left,
                y: top,
            };
        },
        /*
			内置函数
			删除本对象的所有属性
		*/
        removeChild: function () {
            if (this.playerType == "html5video") {
                //删除计时器
                var i = 0;
                var timerArr = [
                    this.timerError,
                    this.timerFull,
                    this.timerTime,
                    this.timerBuffer,
                    this.timerClick,
                    this.timerCBar,
                    this.timerVCanvas,
                ];
                for (i = 0; i < timerArr.length; i++) {
                    if (timerArr[i] != null) {
                        if (timerArr[i].runing) {
                            timerArr[i].stop();
                        }
                        timerArr[i] = null;
                    }
                }
                //删除事件监听
                var ltArr = this.listenerJsArr;
                for (i = 0; i < ltArr.length; i++) {
                    this.removeListener(ltArr[i][0], ltArr[i][1]);
                }
            }
            this.playerType == "";
            this.V = null;
            if (this.conBarShow) {
                this.deleteChild(this.CB["menu"]);
            }
            this.deleteChild(this.PD);
            this.CD.innerHTML = "";
        },
        /*
			内置函数
			画封闭的图形
		*/
        canvasFill: function (name, path) {
            name.beginPath();
            for (var i = 0; i < path.length; i++) {
                var d = path[i];
                if (i > 0) {
                    name.lineTo(d[0], d[1]);
                } else {
                    name.moveTo(d[0], d[1]);
                }
            }
            name.closePath();
            name.fill();
        },
        /*
			内置函数
			画矩形
		*/
        canvasFillRect: function (name, path) {
            for (var i = 0; i < path.length; i++) {
                var d = path[i];
                name.fillRect(d[0], d[1], d[2], d[3]);
            }
        },
        /*
			共用函数
			删除容器节点
		*/
        deleteChild: function (f) {
            var def = this.arrIndexOf(this.elementArr, f.className);
            if (def > -1) {
                this.elementArr.splice(def, 1);
            }
            var childs = f.childNodes;
            for (var i = childs.length - 1; i >= 0; i--) {
                f.removeChild(childs[i]);
            }

            if (f && f != null && f.parentNode) {
                try {
                    if (f.parentNode) {
                        f.parentNode.removeChild(f);
                    }
                } catch (event) {
                }
            }
        },
        /*
			内置函数
		 	根据容器的宽高,内部节点的宽高计算出内部节点的宽高及坐标
		*/
        getProportionCoor: function (stageW, stageH, vw, vh) {
            var w = 0,
                h = 0,
                x = 0,
                y = 0;
            if (stageW / stageH < vw / vh) {
                w = stageW;
                h = (w * vh) / vw;
            } else {
                h = stageH;
                w = (h * vw) / vh;
            }
            x = (stageW - w) * 0.5;
            y = (stageH - h) * 0.5;
            return {
                width: parseInt(w),
                height: parseInt(h),
                x: parseInt(x),
                y: parseInt(y),
            };
        },
        /*
			共用函数
			将字幕文件内容转换成数组
		*/
        parseSrtSubtitles: function (srt) {
            var subtitlesArr = [];
            var textSubtitles = [];
            var i = 0;
            var arrs = srt.split("\n");
            var arr = [];
            var delHtmlTag = function (str) {
                return str.replace(/<[^>]+>/g, ""); //去掉所有的html标记
            };
            for (i = 0; i < arrs.length; i++) {
                if (arrs[i].replace(/\s/g, "").length > 0) {
                    arr.push(arrs[i]);
                } else {
                    if (arr.length > 0) {
                        textSubtitles.push(arr);
                    }
                    arr = [];
                }
            }
            for (i = 0; i < textSubtitles.length; ++i) {
                var textSubtitle = textSubtitles[i];
                if (textSubtitle.length >= 2) {
                    var sn = textSubtitle[0]; // 字幕的序号
                    var startTime = this.toSeconds(
                        this.trim(textSubtitle[1].split(" --> ")[0]),
                    ); // 字幕的开始时间
                    var endTime = this.toSeconds(
                        this.trim(textSubtitle[1].split(" --> ")[1]),
                    ); // 字幕的结束时间
                    var content = [delHtmlTag(textSubtitle[2])]; // 字幕的内容
                    var cktrackdelay = this.vars["cktrackdelay"];
                    if (cktrackdelay != 0) {
                        startTime += cktrackdelay;
                        endTime += cktrackdelay;
                    }
                    // 字幕可能有多行
                    if (textSubtitle.length > 2) {
                        for (var j = 3; j < textSubtitle.length; j++) {
                            content.push(delHtmlTag(textSubtitle[j]));
                        }
                    }
                    // 字幕对象
                    var subtitle = {
                        sn: sn,
                        startTime: startTime,
                        endTime: endTime,
                        content: content,
                    };
                    subtitlesArr.push(subtitle);
                }
            }
            return subtitlesArr;
        },
        /*
			共用函数
			计时器,该函数模拟as3中的timer原理
			time:计时时间,单位:毫秒
			fun:接受函数
			number:运行次数,不设置则无限运行
		*/
        timer: function (time, fun, number) {
            var thisTemp = this;
            this.time = 10; //运行间隔
            this.fun = null; //监听函数
            this.timeObj = null; //setInterval对象
            this.number = 0; //已运行次数
            this.numberTotal = null; //总至需要次数
            this.runing = false; //当前状态
            this.startFun = function () {
                thisTemp.number++;
                thisTemp.fun();
                if (
                    thisTemp.numberTotal != null &&
                    thisTemp.number >= thisTemp.numberTotal
                ) {
                    thisTemp.stop();
                }
            };
            this.start = function () {
                if (!thisTemp.runing) {
                    thisTemp.runing = true;
                    thisTemp.timeObj = window.setInterval(thisTemp.startFun, time);
                }
            };
            this.stop = function () {
                if (thisTemp.runing) {
                    thisTemp.runing = false;
                    window.clearInterval(thisTemp.timeObj);
                    thisTemp.timeObj = null;
                }
            };
            if (time) {
                this.time = time;
            }
            if (fun) {
                this.fun = fun;
            }
            if (number) {
                this.numberTotal = number;
            }
            this.start();
        },
        /*
			共用函数
			将时分秒转换成秒
		*/
        toSeconds: function (t) {
            var s = 0.0;
            if (t) {
                var p = t.split(":");
                for (i = 0; i < p.length; i++) {
                    s = s * 60 + parseFloat(p[i].replace(",", "."));
                }
            }
            return s;
        },
        /*将字符变成数字形式的数组*/
        arrayInt: function (str) {
            var a = str.split(",");
            var b = [];
            for (var i = 0; i < a.length; i++) {
                if (this.isUndefined(a[i])) {
                    a[i] = 0;
                }
                if (a[i].substr(-1) != "%") {
                    a[i] = parseInt(a[i]);
                }
                b.push(a[i]);
            }
            return b;
        },
        /*
			共用函数
			将对象Object标准化
		*/
        standardization: function (o, n) {
            //n替换进o
            var h = {};
            var k;
            for (k in o) {
                h[k] = o[k];
            }
            for (k in n) {
                var type = "";
                if (h[k]) {
                    type = this.varType(h[k]);
                }
                switch (type) {
                    case "number":
                        h[k] = parseFloat(n[k]);
                        break;
                    default:
                        h[k] = n[k];
                        break;
                }
            }
            return h;
        },
        objectAssign: function (o, n) {
            if (this.varType(o) != "object" || this.varType(n) != "object") {
                return null;
            }
            var obj1 = this.newObj(o),
                obj2 = this.newObj(n);
            for (var k in obj2) {
                if (this.varType(obj2[k]) == "object") {
                    if (this.varType(obj1[k]) != "object") {
                        obj1[k] = {};
                    }
                    obj1[k] = this.objectAssign(obj1[k], obj2[k]);
                } else {
                    obj1[k] = obj2[k];
                }
            }
            return obj1;
        },
        /*
			共用函数
			搜索数组
		 */
        arrIndexOf: function (arr, key) {
            if (this.isUndefined(arr) || this.isUndefined(key)) {
                return -1;
            }
            var re = new RegExp(key, [""]);
            return arr.toString().replace(re, "┢").replace(/[^,┢]/g, "").indexOf("┢");
        },
        /*
			共用函数
			去掉空格
		 */
        trim: function (str) {
            if (str != "") {
                return str.replace(/(^\s*)|(\s*$)/g, "");
            }
            return "";
        },
        /*
			共用函数
			输出内容到控制台
		*/
        log: function (val) {
            try {
                console.log(val);
            } catch (e) {
            }
        },
        /*
			共用函数
			弹出提示
		*/
        eject: function (er, val) {
            if (!this.vars["debug"]) {
                return;
            }
            var errorVal = er[1];
            if (!this.isUndefined(val)) {
                errorVal = errorVal.replace("[error]", val);
            }
            var value = "error " + er[0] + ":" + errorVal;
            try {
                this.log(value);
            } catch (e) {
            }
        },
        /*
			共用函数
			系统错误
		*/
        sysError: function (er, val) {
            var ele = this.getByElement(this.vars["container"]);
            var errorVal = er[1];
            if (!this.isUndefined(val)) {
                errorVal = errorVal.replace("[error]", val);
            }
            var value = "error " + er[0] + ":" + errorVal;
            ele.innerHTML = value;
            this.css(ele, {
                backgroundColor: "#000",
                color: "#FFF",
                textAlign: "center",
                lineHeight: ele.offsetHeight + "px",
            });
        },
        /*
			共用函数
			判断变量类型
		*/
        varType: function (val) {
            if (val === null) {
                return "string";
            }
            var type = typeof val;
            switch (type) {
                case "string":
                    return "string";
                    break;
                case "number":
                    return "number";
                    break;
                case "boolean":
                    return "boolean";
                    break;
                case "function":
                    return "function";
                    break;
                case "symbol":
                    return "symbol";
                    break;
                case "object":
                    if (!this.isUndefined(typeof val.length)) {
                        return "array";
                    }
                    return "object";
                    break;
                case "undefined":
                    return "undefined";
                    break;
                default:
                    return typeof val;
                    break;
            }
        },
        /*
			获取此js文件所在路径
		*/
        getPath: function () {
            var scriptList = document.scripts,
                thisPath = scriptList[scriptList.length - 1].src;
            for (var i = 0; i < scriptList.length; i++) {
                var scriptName =
                    scriptList[i].getAttribute("name") ||
                    scriptList[i].getAttribute("data-name");
                var src = scriptList[i].src.slice(
                    scriptList[i].src.lastIndexOf("/") + 1,
                    scriptList[i].src.lastIndexOf("."),
                );
                if (
                    (scriptName &&
                        (scriptName == "ckplayer" || scriptName == "ckplayer.min")) ||
                    (scriptList[i].src && (src == "ckplayer" || src == "ckplayer.min"))
                ) {
                    thisPath = scriptList[i].src;
                    break;
                }
            }
            return thisPath.substring(0, thisPath.lastIndexOf("/") + 1);
        },
        getConfigObject: function () {
            return this.jsonConfig;
        },
        getStyleObject: function () {
            return this.jsonStyle;
        },
        getLanguageObject: function () {
            return this.jsongLanguage;
        },
    };
    window.ckplayer = ckplayer;
})();
